import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.awt.*;
import javax.swing.*;

public class TaskThreadDemo extends JFrame{
  public static void main(String[] args) {
    // Create tasks
    Runnable printA = new PrintChar('a', 100);
    Runnable printB = new PrintChar('b', 100);
    Runnable print100 = new PrintNum(100);

    // Create threads
    Thread thread1 = new Thread(printA);
    Thread thread2 = new Thread(printB);
    Thread thread3 = new Thread(print100);

    // Start threads
    thread1.start();
    thread2.start();
    thread3.start();

    Output frame = new Output();
    frame.pack();
    frame.setLocationRelativeTo(null);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setTitle("lab9");
    frame.setVisible(true);

  }
}
class Output extends JPanel{
        private TextArea jtaOutput = new TextArea();


        Output(){

            jtaOutput.setLineWrap(true);
            jtaOutput.setWrapStyleWord(true);

            ScrollPane scrollPane = new ScrollPane(jtaOutput);
            setLayout(new FlowLayout());
            add(scrollPane);
        }
}

// The task for printing a specified character in specified times
class PrintChar implements Runnable
{
      private char charToPrint; // The character to print
      private int times; // The times to repeat
      private static Lock lock = new ReentrantLock();


      /** Construct a task with specified character and number of
       *  times to print the character
       */
      public PrintChar(char c, int t)
      {
        charToPrint = c;
        times = t;
      }

      /** Override the run() method to tell the system
       *  what the task to perform
       */
      public void  run()
      {
        lock.lock();
          try{
                Thread.sleep(100);
                for (int i = 0; i < times; i++)
                {
                      System.out.print(charToPrint);
                }
            }
        catch (InterruptedException ex){
            ex.printStackTrace();
        }

        finally
        {
            lock.unlock();
        }
    }
}

// The task class for printing number from 1 to n for a given n
class PrintNum implements Runnable
{
    private int lastNum;
    private static Lock lock = new ReentrantLock();

      /** Construct a task for printing 1, 2, ... i */
      public PrintNum(int n)
      {
        lastNum = n;
      }

      /** Tell the thread how to run */
      public void run()
      {
        lock.lock();
        try{
              for (int i = 1; i <= lastNum; i++)
                {
                  System.out.print(" " + i);
            }
        }
      finally{
          lock.unlock();
      }
    }
}

import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.awt.*;
import javax.swing.*;
import java.lang.*;
import java.io.*;
import java.util.*;
import java.awt.event.*;
import java.awt.Graphics;
import java.util.Scanner;
import javax.swing.JTextArea.*;

public class TaskThreadDemo extends JFrame{
  TaskThreadDemo(){
      outputPanel p1 = new outputPanel();
        setLayout(new FlowLayout());

        add(p1);
  }

  public static void main(String[] args) {


    // Create tasks
    Runnable printA = new PrintChar('a', 100);
    Runnable printB = new PrintChar('b', 100);
    Runnable print100 = new PrintNum(100);

    // Create threads
    Thread thread1 = new Thread(printA);
    Thread thread2 = new Thread(printB);
    Thread thread3 = new Thread(print100);

    // Start threads
    thread1.start();
    thread2.start();
    thread3.start();


    TaskThreadDemo frame = new TaskThreadDemo();
    frame.pack();
    frame.setLocationRelativeTo(null);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setTitle("lab9");
    frame.setVisible(true);
    frame.setSize(500,500);

  }


}
class Output{
        char input1;
        int input2;
        String out = " ";

        Output(){
        }


        public Output(char text, int n)
        {
            this.input1 = text;
            this.input2 = n;
        }

        public void setOutput(char text, int n){
            String internal = " ";


            if (text != '\\')
            {
                internal = Character.toString(text);
                out +=internal;
                internal = " ";
            }
            if (n != 0)
            {
                internal = Integer.toString(n);
                out += internal;
                internal = " ";
            }
            this.out = out;
        }
        public String getOutput(){
            return out;
        }
}

class outputPanel extends JPanel{
    Output outtext = new Output();

    String text = outtext.getOutput();

    outputPanel()
    {
        JTextArea jtaOutput = new JTextArea(text,10,20);
        jtaOutput.setLineWrap(true);
        jtaOutput.setWrapStyleWord(true);
        jtaOutput.setEditable(false);

        JScrollPane scrollPane = new JScrollPane(jtaOutput);
        setLayout(new FlowLayout());
        add(scrollPane);
    }
}
// The task for printing a specified character in specified times
class PrintChar implements Runnable
{

      Output output = new Output();
      private char charToPrint; // The character to print
      private int times; // The times to repeat
      private static Lock lock = new ReentrantLock();


      /** Construct a task with specified character and number of
       *  times to print the character
       */
      public PrintChar(char c, int t)
      {
        charToPrint = c;
        times = t;
      }

      /** Override the run() method to tell the system
       *  what the task to perform
       */
      public void  run()
      {
        lock.lock();
          try{
                Thread.sleep(100);
                for (int i = 0; i < times; i++)
                {
                      output.setOutput(charToPrint, 0);
                }
            }
        catch (InterruptedException ex){
            ex.printStackTrace();
        }

        finally
        {
            lock.unlock();
        }
    }
}

// The task class for printing number from 1 to n for a given n
class PrintNum implements Runnable
{
    Output output = new Output();
    private int lastNum;
    private static Lock lock = new ReentrantLock();

      /** Construct a task for printing 1, 2, ... i */
      public PrintNum(int n)
      {
        lastNum = n;
      }

      /** Tell the thread how to run */
      public void run()
      {
        lock.lock();
        try{
              for (int i = 1; i <= lastNum; i++)
                {
                  output.setOutput('\\', i);
            }
        }
      finally{
          lock.unlock();
      }
    }
}

class outputPanel extends JPanel{
    Output outtext = new Output();

    String text = outtext.getOutput();

    outputPanel()
    {
        JTextArea jtaOutput = new JTextArea(text,10,20);
        jtaOutput.setLineWrap(true);
        jtaOutput.setWrapStyleWord(true);
        jtaOutput.setEditable(false);

        JScrollPane scrollPane = new JScrollPane(jtaOutput);
        setLayout(new FlowLayout());
        add(scrollPane);
    }
}