Java Multithreading

Multithreading is a Java feature that allows concurrent execution of two or more parts of a program and each part can handle a different task at the same time making optimal use of the available resources specially when your computer has multiple CPUs.
Each part of such program is called a thread.

A thread is a small and lightweight subprocess, the smallest unit of processing. It has a separate path of execution.
Threads are independent. If there occurs exception in one thread, it doesn't affect other threads. It uses a shared memory area.

• Extending the Thread class
• Implementing the Runnable Interface

A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. The following diagram shows the complete life cycle of a thread.

Following are the stages of the life cycle −
New born state− A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a new born thread.

Runnable state − After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.

Waiting state− Sometimes, a thread transitions to the waiting state while the thread waits for another thread to perform a task. A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.

Timed Waiting − A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.

Terminated (Dead state) − A runnable thread enters the terminated state when it completes its task or otherwise terminates.

Every Java thread has a priority that helps the operating system determine the order in which threads are scheduled.
Java thread priorities are in the range between MIN_PRIORITY (a constant of 1) and MAX_PRIORITY (a constant of 10). By default, every thread is given priority NORM_PRIORITY (a constant of 5).
Threads with higher priority are more important to a program and should be allocated processor time before lower-priority threads. However, thread priorities cannot guarantee the order in which threads execute and are very much platform dependent.

Thread creation by extending the Thread class
We create a class that extends the java.lang.Thread class. This class overrides the run() method available in the Thread class. A thread begins its life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. Start() invokes the run() method on the Thread object.

class Thread1 extends Thread
{
int i;
public void run()
{
for(i=1;i<=20;i++)
{
System.out.println("Inside Thread1 "+i);
}
System.out.println("End of Thread1");
}
}
class Thread2 extends Thread
{
int i;
public void run()
{
for(i=1;i<=20;i++)
{
System.out.println("Inside Thread2 "+i);
}
System.out.println("End of Thread2");
}
}
class Thread3 extends Thread
{
int i;
public void run()
{
for(i=1;i<=20;i++)
{
System.out.println("Inside Thread3 "+i);
}
System.out.println("End of Thread3");
}
}
public class MultiThredingEx {
public static void main(String[] args)
{
Thread1 th1=new Thread1();
Thread2 th2=new Thread2();
Thread3 th3=new Thread3();
th1.start();
th2.start();
th3.start();    
}    //end of main
}//end of main class

class Thread1 extends Thread
{
int i;
public void run()
{
for(i=1;i<=20;i++)
{
System.out.println("Inside Thread1 "+i);
}
System.out.println("End of Thread1");
}
}
class Thread2 extends Thread
{
int i;
public void run()
{
for(i=1;i<=20;i++)
{
System.out.println("Inside Thread2 "+i);
}
System.out.println("End of Thread2");
}
}
class Thread3 extends Thread
{
int i;
public void run()
{
for(i=1;i<=20;i++)
{
System.out.println("Inside Thread3 "+i);
}
System.out.println("End of Thread3");
}
}
public class MultiThredingEx {
public static void main(String[] args)
{
Thread1 th1=new Thread1();
Thread2 th2=new Thread2();
Thread3 th3=new Thread3();
th3.setPriority(Thread.MAX_PRIORITY);
th2.setPriority(Thread.NORM_PRIORITY);
th1.setPriority(Thread.MIN_PRIORITY);
th1.start();
th2.start();
th3.start();    
}  //end of main
}//end of main class