Multithreaded Programming in java

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"); } }}