Create Lightweight Heavyweight Threads

Create Lightweight Heavyweight Threads

Summary: In this tutorial "Create Lightweight Heavyweight Threads", you will create both lightweight and heavyweight threads in simple terms, programs and screenshots.

We know earlier, the meaning of heavyweight and lightweight threads in in Java Thread Basics with figures. Now, let us see how to create them.

1. Creating Heavyweight Threads

We know earlier, multithreading is nothing but executing multiple threads simultaneously. In the following program, two threads of different classes, Test1 and Test2 are created and executed. One thread prints the numbers in ascending order and the other in descending order, alternatively. As these threads belong to two different classes, it is an example of heavyweight process.

class Test1 extends Thread  
{
  public void run()   
  {
    for(int i=0; i<10;  i++)   
    {
      System.out.println("Test1: " + i);
      try  
      {
	Thread.sleep(1000);
      }
      catch(InterruptedException e)  
      { 
        e.printStackTrace();  
      }
    }    
  }   
}
class Test2 extends Thread   
{
  public void run()   
  {
    for(int i=9; i>=0; i--)   
    {
      System.out.println("Test2: " + i);
      try  
      {
        Thread.sleep(1000);
      }
      catch(InterruptedException e)  
      { 
        e.printStackTrace();  
      }
    }     
  }     
 }
 public class TwoRuns    
 {
   public static void main(String args[])  
   {
     Test1 t1  = new Test1();     
     Test2 t2  = new Test2();     
     t1.start();   
     t2.start();   
     try    
     {   
       t1.join();   
       t2.join();    
     }        				 
     catch( InterruptedException e )  
     { 
       e.printStackTrace(); 
     }
   }    
}               

The t1 prints 0 and becomes inactive for 1000 milliseconds by calling sleep() method. As the microprocessor does not have any work (or idle), it allocates its time to the waiting thread t2. t2 prints 9 and goes for sleep for 1000 milliseconds. Meantime, t1 comes out of sleep time, becomes active, prints 1 and again goes for sleep. Then t2 awakes, prints 8 and goes for sleep. Like this, the two loops managed by two threads (belonging to two different processes), t1 and t2, print the numbers alternatively. At any time given, only one thread is active and all the remaining are inactive. You can change the sleep timings and find the difference in output.

Observe, when t1 is active, t2 is inactive and when t2 is active, t1 is inactive. sleep() method is the easiest way, a programmer can shift the execution control from one thread to the other. Other methods also exist, but to activate an inactive thread, it requires an extra method call; this we get later.

Note : At different times of execution, you may see t2 starts first even though t1 is started first. It wholly depends on your processor speed and time availability.

t1.join();

One thread creates the other. The first thread, implicitly created and executed at the beginning of the process, is main thread. For us, main() is a method, but internally it is a thread. Do not get confused, there is a thread group on the name of main; this we get later. In the above program, main thread created t1 and t2 threads. main thread is known as parent thread and t1 and t2 are known as child threads. Here, the parent thread is main and it need not be the main, it can be another thread also. In multithreaded programming, the programmer should see that child thread dies first and then its creator, parent thread. If not, t1 and t2 become orphan threads and output may differ (again depends on the processor speed). Then, how to make the parent thread to die always later than the child. Call simply join() method on the child thread. join() method is an instruction to the JVM to see that parent thread should not be allowed to die before child dies, even if the parent thread completes its job early.

e.printStackTrace();

It is another style of printing the system defined exception message.