If we talk about the mechanism of synchronization, then as one thread exits from the monitor then it must inform the waiting threads that it has left the monitor, now suspended thread can proceed to acquire the lock on the resources or entered in the monitor. If that is not possible then the waiting thread will always be in the waiting list. So, to solve this problem threads must communicate with each other.

Java provides a set of methods by which they can communicate to each other.

Object class has some final methods for such purposes. All these methods can be called only from the synchronized context.

wait(): tells the calling thread to leave the monitor and go to sleep until some other thread enters the same monitor and calls notify( ).

notify(): give a wake up signal or call to the first thread that called wait( ) on the same object.

notify All( ): give a wake up signal or call to all the threads that called wait( ) on the same object. The highest priority thread will run first.

These methods are declared within Object, as shown here:

final void wait ( ) throws InterruptedException

final void notify( )

final void notifyAll( )

Example:

public class CubbyHole {
        private int contents;
        private boolean available false;
        public synchronized int get() {
            while (available == false) {
                try { wait (); }
                catch (InterruptedException e) { }
            }
            available = false;
            notifyAll();
            return contents;
        }
        public synchronized void put(int value) {
             while (available == true) {
                 try { wait(); }
                 catch (InterruptedException e) { }
              }
              contents = value;
              available = true;
              notifyAll();
         }
}

 Priority allow the scheduler to take the decision when the thread should be allowed to run, and in which order. The higher priority threads get more CPU time then lower priority threads. A lower priority thread can be preempted by higher priority thread. The threads having equal priority get equal CPU time.

To set a thread’s priority, use the setPriority( ) method, which belongs to Thread class. Prototypes is as

                           final void setPriority(int priorityValue)

Here, priority Value give the new priority for the calling thread. The value of priorityValue must be within the range MIN_PRIORITY and MAX_PRIORITY. Values of these constants are I and 10, respectively. A thread default priority is NORM_PRIORITY, which is currently 5. These priorities constants are defined as final variables within Thread.

You can get current priority value of the thread by calling the getPriority( ) method of Thread, shown here.

                          final int getPriority( )

Example:

public class Main

{

             public void setPrioritiesOnThreads()

      {

                Thread thread1 = new Thread(new TestThread(1));

                Thread thread2 = new Thread(new TestThread(2));

                thread1.start();

                thread2.start();

            try

            {

                   thread1.join ();

                   thread2.join ();

             }

                 catch (InterruptedException ex)

                    {

                           ex.printStackTrace();

                     }

                 System.out.println(“Done.”);

         }

              public static void main(String[] args)

                 {

                         new Main().setPrioritiesOnThreads();

                  }

                        class TestThread implements Runnable

                       {

                             int id;

                              public TestThread(int id)

                                  {

                                        this.id = id;

                                  }

                                     public void run()

                                         {

                                                for (int i = 1; i <= 10; i++)

                                                      {

                                                           System.out.println(“Thread” + id + “: ” + i);

                                                       }

                                          }

                         }

}

Output:

The output is without priority assigning to the thread. Both thread are executing not in exact order, but executing concurrently.

If we assign the priority to the thread then the code is given below.

public class Main

{

            public void setPrioritiesOnThreads()

      {

                  Thread thread1 = new Thread(new TestThread(1));

                  Thread thread2 = new Thread(new TestThread(2));

                  thread1.setPriority(Thread.MAX_PRIORITY);

                  thread2.setPriority(Thread.MIN_PRIORITY);

                  thread1.start();

                  thread2.start();

                    try

                     {

                         thread1.join ();

                         thread2.join ();

                     }

                          catch (InterruptedException ex)

                              {

                                ex.printStackTrace();

                               }

                                System.out.println(“Done.”);

         }

                   public static void main(String[] args)

            {

                  new Main().setPrioritiesOnThreads();

             }

                 class TestThread implements Runnable

               {

                    int id;

                      public TestThread(int id)

                      {

                            this.id = id;

                       }

                      public void run()

                      {

                              for (int i = 1; i <= 10; i++)

                                 {

                                       System.out.println(“Thread” + id + “: ” + i);

                                  }

                       }

                }

}

Now the thread1 has the highest priority so it executes first:

class NewThreadDemo implements Runnable

{
            Thread t;
            NewThreadDemo(String threadName)
      {
            t=new Thread(this, threadName);
            System.out.println(“New userdefined child thread created” +threadName);
            t.start();
       }

                 public void run()
            {
                try
                 {
                      for(int i = 1; i <=10; i++)
                       {
                           System.out.println(“Child Thread: [” +Thread.currentThread().getName()
+ “] ” + i);
                           Thread.sleep(500);
                        }
                  }
                      catch (InterruptedException e)
                         {
                              System.out.println(“UseDefine Child interrupted.”);
                          }
                      System.out.println(“Exiting UserDeinfed child thread.”);
               }
}
class MultiThreadDemo
      {
                    public static void main(String args[])
               {
                    NewThreadDemo ch1 = new NewThreadDemo(“Child_One”);
                    NewThreadDemo ch2 = new NewThreadDemo(“Child_Two”);
                    NewThreadDemo ch3 = new NewThreadDemo(“Child_Three”);
                    NewThreadDemo ch4 = new NewThreadDemo(“Child_FOur”);

                    System.out.println(“Child Thread One is alive: ” + ch1.t.isAlive());
                    System.out.println(“Child Thread Two is alive: “+ ch2.t.isAlive());
                    System.out.println(“Child Thread Three is alive: “+ ch3.t.isAlive());
                    System.out.println(“Child Thread Four is alive: “+ch4.t.isAlive());

                     try
                      {
                         System.out.println(“Waiting for child threads to finish.”);
                         ch1.t.join ();
                         ch2.t.join ();
                         ch3.t.join ();
                         ch4.t.join ();
                       }

                           catch (InterruptedException e)
                                {

                                     System.out.println(“Main thread Interrupted”);
                                }
                              System.out.println(“Child Thread One is alive: ” + ch1.t.isAlive());
                              System.out.println(“Child Thread Two is alive: “+ ch2.t.isAlive());
                              System.out.println(“Child Thread Three is alive: “+ ch3.t.isAlive());
                              System.out.println(“Child Thread Four is alive: “+ch4.t.isAlive());
                              System.out.println(“Main thread exiting.”);

                  }
      }

In the code all child thread are join(). If see the output, the main thread exited in the mid of the running code. It wait for all child to be exit. At last it exits from the code.

Output

By implementing the Runnable interface the thread creation is the easiest way. You can construct a thread on any type of object that implements Runnable. To implement Runnable interface, a new class need only to implement run() method. When you implement the Runnable interface then create an instance of Thread from within that class. The Thread class has several constructor.

public Thread ()

public Thread(String thread_Name)

public Thread(Runnable threadObj)

public Thread(Runnable threadObj, String thread_Name)

public Thread(ThreadGroup groupObj, Runnable threadObj)

public Thread(ThreadGroup groupObj, Runnable threadObj, String name)

After the new thread is created, the start( ) method has to be used to start running, otherwise it will not be started. In essence, start( ) executes a call to run( ).

Example:

class NewThreadDemo implements Runnable

{

            Thread t;

            NewThreadDemo()

       {

               t=new Thread(this, “User Define Thread”);

               System.out.println(“New userdefined child thread created” + this);

               t.start();

        }

               public void run ()

              {

                    try

                     {

                         for(int i = 1; i <=10; i++)

                              {

                                  System.out.println(“UserDefined Child Thread: ” + i);

                                  Thread.sleep(500);

                               }

                      }

                            (InterruptedException e)

                            {

                                System.out.println(“UseDefine Child interrupted.”);

                             }

                             System.out.println(“Exiting UserDeinfed child thread.”);

                }

}

class ThreadDemo

{

                     public static void main(String args[])

              {

                      new NewThreadDemo();

                     try

                      {

                            for(int i = 1; i <10; i++)

                               {

                                     System.out.println(“Main Thread: ” + i);

                                     Thread.sleep(500);

                                }

                       }

                        catch (InterruptedException e)

                                  {

                               System.out.println(“Main thread interrupted.”);

                                  }

                               System.out.println(“Main thread exiting.”);

                 }

}

Output:

The program was run three times, and all time different output was generated.

In Java, a user defined thread can be created to implement the Runnable interface. The Runnable interface has only one method run() that you must have to implement in your class, that you want to create as thread. The run() is the method in which that code is written, which is counted as thread task.

The content of the run() method will be counted as thread portion, but the method written outside the Run() counts as part of the main thread. Both the new thread and main thread can run concurrently. The thread terminates· with the termination of run method. Control is returned to the caller method of the run method, or can say from where it starts. The run() method should not be called directly, the start() method of thread class is called, and that is responsible to call run() for the corresponding thread.

Another way to create a thread is to inherit the Thread class. Thread class has a number of methods. Few of them are static and few are non-static. As per the need you can override non-static methods. But run() method must override, because it defines new thread functionality.

Extending Thread

A new thread is created by creating a new class that extends Thread, and then create an instance of that class. The extending class must override the method run(), which is the entry point of the new thread (user defined). To begin the execution of the new thread, it must call start() method. Inside the run() method, you’ll write the code, which is considered as the functionality of the thread. The run() method can call other method of the same class or other class using their objects. It is an entry point of the thread. As the run() method returns (exit or terminate) the thread ends.

Example:

class NewThreadDemo extends Thread {

         public NewThreadDemo() {

               super(“User Define Thread”);

               System.out.println(“New userdefined child thread created “ + this);

               start();

          }

          public void run() {

                   try {

                         for(int i = 1; i <=10; i++) {

                              System.out.println(“UserDefined Child Thread: “ + i);

                              Thread.sleep(500);

                            }

                     }

                    catch (InterruptedException e) {

                          System.out.println(“UseDefine Child interrupted.”);

                    }

                          System.out.println(“Exiting UserDeinfed child thread.”);

              }

}

class ThreadDemo {

     public static void main(String args[]) {

         new NewThreadDemo();

         try {

              for(int i = 1; i <10; i++) {

                  System.out.println(“Main Thread: “ + i);

                  Thread.sleep(500);

              }

          }

             catch (InterruptedException e) {

                   System.out.println(“Main thread interrupted.”);

             }

                   System.out.println(“Main thread exiting.”);

        }

}

There are two output of the same thread code. Because it is not always sure that a thread executes in the same manner. The output can be same or vary every time. The super() inside the NewThreadDemo constructor invokes the following form of Thread constructor:

public Thread(String thread_Name)

As any Java program comes under execution, first thread starts immediately, called the main thread. There are two importance’s of main thread as follows:

It is the parent of all the threads of the program and all other “child” threads will be spawned form it.

It must be the last thread to finish the execution of the program.

As your program start, the main thread is created automatically, under the control of Thread object. But, if you want the reference of the main thread then there is a static method curentThread() of Thread class, which returns the reference of thread in which it is called. Its general form is shown here:

static Thread currentThread( )

Example:

class MainThreadDemo

{

                      public static void main (String ar[] )

            {

                     Thread t = Thread.currentThread();

                     System.out.println(“Current thread: ” + t);

                     t.setName(“Main Thread Demo”);

                     System.out.println(“New name of main Thread: ” + t);

                 try

                  {

                       for(int n=1;n<=10;i++)

                            {

                                 System.out.print(i + ‘\t’);

                                 Thread.sleep(500);

                             }

                   }

                        catch(InterruptedException ie)

                      {

                               System.out.println(ie);

                       }

              }

}

Output:

Current thread: Thread[main,S,main]

New name of main Thread: Thread[Main Thread Demo,5,main]

1              2              3              4              5              6              7              8              9             10

Output is showing three line statement. In first statement within square brackets “[]” first value is the name of thread “main”, second is priority “5” and the last is the name of thread group “main”, the current (main) thread belongs to. Similarly in the second printed statement first value is name of the thread after modification “Main Thread Demo”, second is priority “5” and the last is thread group name “main”. The default created group by java is “main”. In the last it will print I to 10 and each digit after 0.5 second. In the above example setName() is used to change the name of the thread. You can get the name of the thread by calling getName(). Both of these methods are of Thread class. There prototype is given below:

final void setName(String threadName)

final String getName() ,

To give a pause to the thread sleep() method is used in the given example. The argument passed to sleep() method are in milliseconds. There are two versions of sleep() methods of Thread class as following:

static void sleep(long time_in_milliseconds) throws InterruptedException

static void sleep(long time_in_milliseconds, int additional_nanoseconds)

throws InterruptedException