Thread: A Thread is a single Sequential flow of control with in a program. In java thread can be implemented in two ways. one is by "implementing" Runnable interfaces and the other way is by "Extending" thread class .
Thread class defines several methods that help manage threads.

Method	Meaning
getName	Obtain a thread's Name
getPriority	Obtain a thread's Priority
isAlive	Determine if a thread is still Running
join	Wait for a thread to terminate.
run	Entry point for the thread.
sleep	Suspend a thread for a period of time.
start	start a thread by calling its run method.

Implementing Thread Class: The easiest way to create a thread is to create a class that implements the Runnable interface. Runnable abstracts aunit of executable code. you can construct a thread on any object that implements Runnable. to implement Runnable, a calss need only implement a single method called run(), which is declared like this:
Public void run()
you create a class that implements Runnable, you will instantiate an object of type Thread from within that class. Thread defines several constructors. The one that we will use is shown here:
Thread(Runnable threadObject, String threadName)
In this constructor, threadObject is an instance of a class that implements the Runnable interface. This defines where execution of the thread will begin. The name of the new thread is specified by threadName.
The new thread is created, it will not start running until you call its start() method, which is declared within Thread. in essence, start() executes a class to runn(). The start() method is shown here:
void start()
Example:
import java.util.*; class NewThread implements Runnable{ Thread t; NewThread(){ //Create a new, Second thread t=new Thread(this, "Demo Thread"); System.out.println("Child Thread: " +t); t.start(); //Start the thread } // This is the entry point for the second thread. public void run(){ try{ for(int i=5; i>0; i--){ System.out.println("Child Thread : " +i); Thread.sleep(500); } }catch (InterruptedException e){ System.out.println("Child Interrupted"); } System.out.println("Exiting child Thread"); } } class ThreadDemo{ public static void main(String []arg){ new NewThread(); // Create new thread. try{ for(int i=5; i>0; i--){ System.out.println("Main Thread : " +i); Thread.sleep(1000); } }catch (InterruptedException e){ System.out.println("Main Interrupted"); } System.out.println("Exiting MAIN Thread"); } }


Extending Thread: The second way to create a thread is to create a new class that extends Thread, and then to create an interface of that class. the extending class must override the run() method, which is the entry point for the new thread. it must also call start() to begin execution of the new thread. here is the preceding program rewritten to extend Thread:
import java.util.*; class NewThread extends Thread{ NewThread(){ //Create a new, Second thread super("Demo Thread"); System.out.println("Child Thread: " +this); start(); //Start the thread } // This is the entry point for the second thread. public void run(){ try{ for(int i=5; i>0; i--){ System.out.println("Child Thread : " +i); Thread.sleep(500); } }catch (InterruptedException e){ System.out.println("Child Interrupted"); } System.out.println("Exiting child Thread"); } } class ThreadDemo{ public static void main(String []arg){ new NewThread(); // Create new thread. try{ for(int i=5; i>0; i--){ System.out.println("Main Thread : " +i); Thread.sleep(1000); } }catch (InterruptedException e){ System.out.println("Main Interrupted"); } System.out.println("Exiting MAIN Thread"); } }

This program generates the same output as the preceding version. As you can see, the child thread is created by instantiating an object of NewThread, which is derived from Thread.
Notice the call to Super() inside NewThread. This invokes the following from of the Thread constructor:
public Thread(String threadName)
Here, threadNmae Specifies the name of the thread.
Using isAlive() and join():
Sometimes one thread needs to know when another thread is ending. In java, isAlive() and join() are two different methods to check whether a thread has finished its execution.
The isAlive() methods return true if the thread upon which it is called is still running otherwise it return false.
But, join() method is used more commonly than isAlive(). This method waits until the thread on which it is called terminates.
Using join() method, we tell our thread to wait until the specifid thread completes its execution. There are overloaded versions of join() method, which allows us to specify time for which you want to wait for the specified thread to terminate.
Example:
import java.lang.*; public class JoinAliveDemo implements Runnable { public void run() { System.out.println("r1 "); try{ Thread.sleep(1500); }catch(InterruptedException ie){ System.out.println("Interrupted"); } System.out.println("r2 "); Thread t = Thread.currentThread(); // tests if this thread is alive System.out.println("status = " + t.isAlive()); } public static void main(String args[]) throws Exception { Thread t = new Thread(new JoinAliveDemo()); // this will call run() function t.start(); // waits for this thread to die t.join(); // // tests if this thread is alive System.out.println("status = " + t.isAlive()); } }

Thread Priorities:Thread priorities are used by the thread scheduler to decide when each thread should be allow to run.
To set a thread's priority, use the setPriority() method, which is a member of Thread.
final void setPriority(int level)
Here, level specifies the new priority setting for the calling thread. the value of level must be within the range MIN_PRIORITY and MAX_PRIORITY. Currently, these values are 1 and 10, respectively. To returns a thread to default priority, specify NORM_PRIORITY, which is currently 5. These priorities are defined as static final variables within Thread. you can obtain the current priority setting by calling the getPriority() method of Thread, shown here: final int getPriority().

Synchronization: Synchronization is the process of allowing threads to execute one after another. Synchronization control the access the multiple treads to a shared resources without synchronization of threads, one thread can modify a shared variable while another thread can update the same shared variable, which leads to significant error. void Synchronization Example1(){ Synchronization(this);{ //All Code.....} }
Using Synchronization Methods: It is easy in java, because all objects have their own implicit monitor associated with them. To enter on object's monitor, just call a method that has been modified with the synchronized keyword. while a thread is inside a synchronized method, all other threads that try to call it on the same instance have to wait. To exit the monitor and relinquish control of the object to the next waiting thread, the owner of the monitor simply returns form the synchronization method.
Example:
import java.lang.*; class callme{ void call(String msg){ System.out.println("[..Start of call -" +msg); try{ Thread.sleep(1000); }catch(InterruptedException e){ System.out.println("Interrupted"); } System.out.print("End of call...]"); } } class caller implements Runnable{ String msg; callme target; Thread t; public caller(callme targ, String s){ target=targ; msg=s; t=new Thread(this); t.start(); } public void run(){ target.call(msg); } } class synch{ public static void main(String []arg){ callme target=new callme(); caller ob1=new caller(target, "hello"); caller ob2=new caller(target, "synchronization"); caller ob3=new caller(target, "world"); // wait for thread End try{ ob1.t.join(); ob2.t.join(); ob3.t.join(); }catch(InterruptedException e){ System.out.println("Interrupted"); } }}

Java includes an elegant Interprocess communication mechanism via the wait(), notify() and notifyAll() methods.These methods are implemented as final method in object, so all classes have them. all three methods can be called only from within a synchronized context. Although conceptually advanced from a computer science perspective, the rules for using these methods are actually quite simple:
wait(): Tells the calling thread to given up the monitor and go to sleep until some other thread enters the same monitor and calls notify() or notifyAll().
notify(): wakes up a thread that called wait() on the same object.
notifyAll(): wakes up a thread that called wait() on the same object. One of the threads will be granted access.

These methods are declared within Object, as shown here:
final void wait()throws InterruptedException final void notify() final void notifyAll()
The proper way to write this program in java is to use wait() and notify() to signal in both directions, shown here:
//A correct implemenetation of a producer and consumet. class Q{ int n; boolean valueSet=false; synchronized int get(){ while(!valueSet) try{ wait(); }catch(InterruptedException e){ System.out.println("InterruptedException caught"); } System.out.println("Got: " +n); valueSet=false; notify(); return n; } synchronized void put(int n){ while(valueSet) try{ wait(); }catch(InterruptedException e){ System.out.println("InterruptedException caught"); } this.n=n; valueSet=true; System.out.println("PUT: " +n); notify(); } } class producer implements Runnable{ Q q; producer(Q q){ this.q=q; new Thread(this, "Producer").start(); } public void run(){ int i=0; while(i<10){ q.put(i++); } } } class consumer implements Runnable{ Q q; consumer(Q q){ this.q=q; new Thread(this, "consumer").start(); } public void run(){ while(true){ q.get(); } } } class PCFixed{ public static void main(String []arg){ Q q=new Q(); new producer(q); new consumer(q); System.out.println("Please control-c to stop"); }}
Output:

A Special type of error that you need to avoid that relates specifically to multitasking is Deadlock, which occurs when two threads have a circular dependency on a pair of synchronization objects.
Deadlock is a difficult error to debug for two reasons.

• In general, It occurs only rarely, when the two threads time-slice in just the right way.
• It may involve more than two threads and two synchronization object.

Example: A example of Deadlock.
class A{ synchronized void foo(B b){ String name= Thread.currentThread().getName(); System.out.println(name +" Enter A foo"); try{ Thread.sleep(1000); }catch(Exception e){ System.out.println("A Interrupted"); } System.out.println(name + " Trying to call B.last()"); b.last(); } synchronized void last(){ System.out.println("Inside A.last"); } } class B{ synchronized void bar(A a){ String name= Thread.currentThread().getName(); System.out.println(name +" Enter B.bar"); try{ Thread.sleep(1000); }catch(Exception e){ System.out.println("B Interrupted"); } System.out.println(name + " Trying to call A.last()"); a.last(); } synchronized void last(){ System.out.println("Inside A.last"); } } class Deadlock implements Runnable{ A a=new A(); B b=new B(); Deadlock(){ Thread.currentThread().setName("MainThread"); Thread t= new Thread(this, "RacingThread"); t.start(); a.foo(b); // get lock on a in this thread. System.out.println("Back in main thread."); } public void run(){ b.bar(a); // get lock on b in other thread. System.out.println("Back in Other Thread."); } public static void main(String []manoj){ new Deadlock(); } }
Output:

A Thread can exist in a number of different states. you can obtain the current state of a thread by calling the getState() method defined by Thread. It is shown here:
Thread.State getState()
It returns a value of type Thread.State that indicates the state of the thread at the time at which the call was made. State is an enumeration defined by Thread.
Here are the values the can be returned by getState().

Value	State
BLOCKED	A Thread that has suspended execution because it is waiting to acquire a look.
NEW	A Thread that has not begun execution.
RUNNABLE	A Thread that either is currently executing or will execute when it gains access to the CPU.
TERMINATED	A Thread that has completed execution.
TIMED_WAITING	A Thread that hsa suspended execution for a specified period of time, such as when it has called sleep(). This state is also entered when a timeout version of wait() or join() is called.
WAITING	A Thread that has suspended execution because it is waiting for some action to occur. for example, it is waiting because of a call to a non-timeout version of wait() or join().

Figure: Diagrams how the various thread states relate.