Multi Threading in Java

BASICS

By Jeevesh Mishra
 Multi Threading Concepts
• Overview of Thread
• Life Cycle of A Thread
• Thread Creation 
• Thread Constructors
• Introduction to Multithreading
• Creation of Multiple Threads
• Thread Priorities and Scheduler
• Deadlock
• Lock and Synchronized Threads
• Inter-Thread Communication
• Daemon Thread
 Overview of a Thread
• In Java Programming language,  thread is a sequential path of code execution within
a program. Each thread has its own local variables, program counter and lifetime. In
single threaded runtime environment, operations are executes sequentially i.e. next
operation can execute only when the previous one is complete. It exists in a common
memory space and can share both data and code of a program. Threading concept is
very important in Java through which we can increase the speed of any application.
You can see diagram shown below in which a thread is executed along with its
several operations with in a single process. 
 Overview contd…
Main Thread (or main method)
When any standalone application is running, it
firstly execute the main() method runs in a one
thread, called the main thread. If no other
threads are created by the main thread, then
program terminates when the main() method
complete its execution. The main thread creates
some other threads called child threads. The
main() method execution can finish, but the
program will keep running until the all threads
have complete its execution.
 Life Cycle of Threads

• When you are programming with threads, understanding the life cycle of thread is
very valuable. While a thread is alive, it is in one of several states. By invoking start()
method, it doesn’t mean that the thread has access to CPU and start executing
straight away. Several factors determine how it will proceed.

Different states of a thread are :

 Life cycle contd….
• New state – After the creations of Thread instance the thread is in this state but
before the start() method invocation. At this point, the thread is considered not alive.
     
• Runnable (Ready-to-run) state – A thread start its life from Runnable state. A thread
first enters runnable state after the invoking of start() method but a thread can return
to this state after either running, waiting, sleeping or coming back from blocked state
also. On this state a thread is waiting for a turn on the processor. 
     
• Running state – A thread is in running state that means the thread is currently
executing. There are several ways to enter in Runnable state but there is only one
way to enter in Running state: the scheduler select a thread from runnable pool.
     
• Dead state – A thread can be considered dead when its run() method completes. If
any thread comes on this state that means it cannot ever run again.
• Blocked - A thread can enter in this state because of waiting the resources that are
hold by another thread.
 Life cycle contd…
• Different states implementing Multiple-
Threads are:
 Life cycle contd…
• As we have seen different states that may be occur with the single
thread. A running thread can enter to any non-runnable state,
depending on the circumstances. A thread cannot enters directly to
the running state from non-runnable state, firstly it goes to runnable
state. Now lets understand the some non-runnable states which
may be occur handling the multithreads.
– Sleeping – On this state, the thread is still alive but it is not
runnable, it might be return to runnable state later, if a particular
event occurs. On this state a thread sleeps for a specified
amount of time. You can use the method sleep( ) to stop the
running state of a thread.
e.g. staticvoid sleep(long millisecond) throws
InterruptedException
 Life cycle contd…
• Waiting for Notification – A thread waits for
notification from another thread. The thread
sends back to runnable state after sending
notification from another thread.
final void wait(long timeout) throws
InterruptedException
final void wait(long timeout, int nanos)
throws InterruptedException
final void wait() throws InterruptedException
 Life cycle contd..
• Blocked on I/O – The thread waits for
completion of blocking operation. A thread can
enter on this state because of waiting I/O
resource. In that case the thread sends back to
runnable state after availability of resources.
• Blocked for joint completion – The thread can
come on this state because of waiting the
completion of another thread.
• Blocked for lock acquisition – The thread can
come on this state because of waiting to acquire
the lock of an object
 Life cycle contd…
• Methods that can be applied apply on a
Thread:
• Some Important Methods defined in
java.lang.Thread are shown in the table:
 Thread Creation

• In Java, an object of the Thread class can represent a thread. Thread can
be implemented through any one of two ways:
– Extending the java.lang.Thread Class
– Implementing the java.lang.Runnable Interface
 Thread Creation
I. Extending the java.lang.Thread Class
For creating a thread a class have to extend the Thread Class. For creating a thread by this procedure you have
to follow these steps:
• Extend the java.lang.Thread Class.
• Override the run( ) method in the subclass from the Thread class to define the code executed by the thread.
• Create an instance of this subclass. This subclass may call a Thread class constructor by subclass constructor.
• Invoke the start( ) method on the instance of the class to make the thread eligible for running.
• The following program demonstrates a single thread creation extending  the "Thread" Class:
• class MyThread extends Thread{   String s=null;
  MyThread(String s1){
    s=s1;
    start();
  }
  public void run(){
      System.out.println(s);
    }
}
public class RunThread{
  public static void main(String args[]){
   
    MyThread m1=new MyThread("Thread started....");
   }
}
 Thread Creation
• Output of the Program is :
• C:\j2se6\thread>javac RunThread.java

C:\j2se6\thread>java RunThread
Thread started....
 Thread creation
II. Implementing the java.lang.Runnable Interface
The procedure for creating threads by implementing the
Runnable Interface is as follows:
• A Class implements the Runnable Interface, override
the run() method  to define the code executed by
thread. An object of this class is Runnable Object.
• Create an object of Thread Class by passing a
Runnable object as argument.
• Invoke the start( ) method on the instance of the
Thread class.
 Thread creation
• The following program demonstrates the thread creation implenting
the Runnable interface:
• class MyThread1 implements Runnable{
  Thread t;
  String s=null;   MyThread1(String s1){
     s=s1;
    t=new Thread(this);
    t.start();
  }
  public void run(){
      System.out.println(s);
     }
}
public class RunableThread{
  public static void main(String args[]){
    MyThread1 m1=new MyThread1("Thread started....");
    }
}
 Thread creation
• However, this program returns the output
same as of the output generated through
the previous program.
• Output of the Program is:
• C:\j2se6\thread>javac
RunableThread.java

C:\j2se6\thread>java RunableThread
Thread started....
 Thread Creation
There are two reasons for implementing a
Runnable interface preferable to extending the
Thread Class:
• If you extend the Thread Class, that means that
subclass cannot extend any other Class, but if
you implement Runnable interface then you can
do this.
• The class implementing the Runnable interface
can avoid the full overhead of Thread class
which can be excessive.
 Thread Constructors

Several constructors are available for creating new

Thread instances.
    
• Thread()
• Thread(String)            
• Thread(Runnable)
• Thread(Runnable,String)
• Thread(ThreadGroup,String)
• Thread(ThreadGroup,Runnable)
• Thread(ThreadGroup,Runnable,String)
• Thread(ThreadGroup, Runnable, String, long)
 ThreadGroup
• All threads belongs to an instance of the ThreadGroup Class. ThreadGroup is used
to represent a group of threads. ThreadGroups can be shown in a hierarchical
manner. There is only one root ThreadGroup that contains all other thread and
groups and each subgroups can contain other groups and threads. All thread have
only one thread group. And all thread groups (except the root thread group) belongs
to exactly one parent thread group. Threads can access only belonging thread group.
• When a new ThreadGroup is created, it is added as a member of existing
ThreadGroup.
If a thread x in group1, and executes the code:

ThreadGroup group2=new ThreadGroup(“group2”);

Then the newly formed group2 comes under group1. If you want a parent group
other than default then you have to specify the parent group at the time of creation.

ThreadGroup group3=new ThreadGroup(group2,“group3”);

Then newly formed group3 comes under the group2.

 Thread groups contd..
Some important methods are:
• getName() – This method is used to retrieve the name of particular
group.
  ThreadGroup g=new ThreadGroup(“RoseIndia”);
  String gname=g.getName(); 
• getParent() – This method is used to retrieve the name of parent
threadgroup of sub group.
   ThreadGroup group=group3.getParent();  
• activeGroupCount() – This method returns the number of active
thread group in a particular thread group and all its subgroups.
   int size=group.activeGroupCount();       
• getThreadGroup() – This method is used to know the thread is
belong to which thread group.
ThreadGroup group=threadx.getThreadGroup();
 Multithreading in Java

• Introduction
So far you have learned about a single
thread. Lets us know about the concept of
multithreading and learn the
implementation of it. But before that, lets
be aware from the multitasking.
 Multi Threading in Java contd..
• Multitasking :

Multitasking allow to execute more than one tasks at the

same time, a task being a program. In multitasking only
one CPU is involved but it can switches from one
program to another program so quickly that's why it gives
the appearance of executing all of the programs at the
same time. Multitasking allow processes (i.e. programs)
to run concurrently on the program. For Example running
the spreadsheet program and you are working with word
processor also.      
Multitasking is running heavyweight processes by a
single OS.
 Multithreading in Java contd..
Multithreading :
• Multithreading is a technique that allows a program or a process to
execute many tasks concurrently (at the same time and parallel). It
allows a process to run its tasks in parallel mode on a single
processor system 
• In the multithreading concept, several multiple lightweight processes
are run in a single process/task or program by a single processor.
For Example, When you use a word processor you perform a
many different tasks such as printing, spell checking and so on.
Multithreaded software treats each process as a separate program.
• In Java, the Java Virtual Machine (JVM) allows an application to
have multiple threads of execution running concurrently. It allows a
program to be more responsible to the user. When a program
contains multiple threads then the CPU can switch between the two
threads to execute them at the same time. 
 Multithreading in Java contd..
• For example, look at the diagram shown
as:

In this diagram, two threads are being executed

having more than one task.
The task of each thread is switched to the task of
another thread.
 Multithreading in Java contd..
Advantages of multithreading over
multitasking :  
• Reduces the computation time.
• Improves performance of an application.
• Threads share the same address space so it
saves the memory.
• Context switching between threads is usually
less expensive than between processes.     
• Cost of communication between threads is
relatively low.
 Multithreading in Java contd..
• Different states implementing Multiple-
Threads are:

As we have seen different states that may be occur with the single thread.
A running thread can enter to any non-runnable state, depending on the
circumstances. A thread cannot enters directly to the running state from
non-runnable state, firstly it goes to runnable state. Now lets understand
the some non-runnable states which may be occur handling the
multithreads.
 Multithreading in Java contd…
Non-Runnable states understanding :
• Sleeping – On this state, the thread is still alive but it is not runnable, it might be return to
runnable state later, if a particular event occurs. On this state a thread sleeps for a specified
amount of time. You can use the method sleep( ) to stop the running state of a thread.
      
     static void sleep(long millisecond) throws InterruptedException

• Waiting for Notification – A thread waits for notification from another thread. The thread sends
back to runnable state after sending notification from another thread.
       
     final void wait(long timeout) throws InterruptedException
     final void wait(long timeout, int nanos) throws InterruptedException
     final void wait() throws InterruptedException
     
• Blocked on I/O – The thread waits for completion of blocking operation. A thread can enter on
this state because of waiting I/O resource. In that case the thread sends back to runnable state
after availability of resources.
     
• Blocked for joint completion – The thread can come on this state because of waiting the
completion of another thread.
    
• Blocked for lock acquisition – The thread can come on this state because of waiting to acquire
the lock of an object.
 Creation of Multiple Threads

• Like creation of a single thread, You can

also create more than one thread
(multithreads) in a program using class
Thread or implementing interface
Runnable.
 Creation of multiple threads
• Lets see an example having the implementation of the multithreads by extending Thread Class:
• class MyThread extends Thread{
  MyThread(String s){
    super(s);
    start();
  }
  public void run(){
    for(int i=0;i<5;i++){
      System.out.println("Thread Name  :"
              +Thread.currentThread().getName());
      try{
        Thread.sleep(1000);
      }catch(Exception e){}
    }
  }
}
  public class MultiThread1{
  public static void main(String args[]){
    System.out.println("Thread Name :"
           +Thread.currentThread().getName());   
    MyThread m1=new MyThread("My Thread 1");
    MyThread m2=new MyThread("My Thread 2");
  }
}
 Creation of multiple threads
• Output of the program :
 Creating multiple threads
• In this program, two threads are created along
with the "main" thread. The currentThread()
method of the Thread class returns a reference
to the  currently executing thread and the
getName( ) method returns the name of the
thread. The sleep( ) method pauses execution of
the current thread for 1000 milliseconds(1
second) and switches to the another threads to
execute it. At the time of execution of the
program, both threads are registered with the
thread scheduler and the CPU scheduler
executes them one by one.
 Creating Multiple threads
• Using Runnable interface:
Now, lets create the same program implenting the Runnable interface:

• class MyThread1 implements Runnable{
  Thread t;
  MyThread1(String s)  {
    t=new Thread(this,s);
    t.start();
  }
  
  public void run()  {
    for(int i=0;i<5;i++) {
      System.out.println("Thread Name  :"+Thread.currentThread().getName());
      try {
      Thread.sleep(1000);
      }catch(Exception e){}
    }
  }
}
public class RunnableThread1{
  public static void main(String args[])  {
    System.out.println("Thread Name :"+Thread.currentThread().getName());   
    MyThread1 m1=new MyThread1("My Thread 1");
    MyThread1 m2=new MyThread1("My Thread 2");
  }
}
 Creation of multiple threads
• Output of the program:
 Thread Priorities

• In Java, thread scheduler can use the thread priorities

in the form of integer value to each of its thread to
determine the execution schedule of threads . Thread
gets the ready-to-run state according to their priorities.
The thread scheduler provides the CPU time to thread
of highest priority during ready-to-run state.  
• Priorities are integer values from 1 (lowest priority given
by the constant Thread.MIN_PRIORITY) to 10 (highest
priority given by the constant Thread.MAX_PRIORITY).
The default priority is 5(Thread.NORM_PRIORITY)
 Thread priorities contd..
• Description of constants used above.
 Thread Priorities
• The methods that are used to set the priority of thread shown as:

• When a Java thread is created, it inherits its priority from the thread that created
it.  At any given time, when multiple threads are ready to be executed, the
runtime system chooses the runnable thread with the highest priority for
execution. In Java runtime system, preemptive scheduling algorithm is
applied. If at the execution time a thread with a higher priority and all other
threads are runnable then the runtime system chooses the new higher priority
thread for execution. On the other hand, if two threads of the same priority are
waiting  to be executed by the CPU then the round-robin algorithm is applied in
which the scheduler chooses one of them to run according to their round of
time-slice.
 Thread Scheduler
• In the implementation of threading scheduler usually
applies one of the two following strategies:
• Preemptive scheduling – If the new thread has a
higher priority then current running thread leaves the
runnable state and higher priority thread enter to the
runnable state.
   
• Time-Sliced (Round-Robin) Scheduling – A running
thread is allowed to be execute for the fixed time, after
completion the time, current thread indicates to the
another thread to enter it in the runnable state.
Program for getting thread priorities
• You can also set a thread's priority at any time after its creation using the setPriority method. Lets see, how to set and get the priority of a thread.
•  
• class MyThread1 extends Thread{
  MyThread1(String s){
    super(s);
    start();
  }
  public void run(){
    for(int i=0;i<3;i++){
      Thread cur=Thread.currentThread();
      cur.setPriority(Thread.MIN_PRIORITY);
      int p=cur.getPriority();
      System.out.println("Thread Name  :"+Thread.currentThread().getName());
      System.out.println("Thread Priority  :"+cur);
      }
  }
}
  class MyThread2 extends Thread{
  MyThread2(String s){
    super(s);
    start();
  }
public void run(){
    for(int i=0;i<3;i++){
      Thread cur=Thread.currentThread();
      cur.setPriority(Thread.MAX_PRIORITY);
      int p=cur.getPriority();
      System.out.println("Thread Name  :"+Thread.currentThread().getName());
      System.out.println("Thread Priority  :"+cur);
      }
  }
}
public class ThreadPriority{
  public static void main(String args[]){  
    MyThread1 m1=new MyThread1("My Thread 1");
    MyThread2 m2=new MyThread2("My Thread 2");
  }
} 
 Output of the Program:
• javac ThreadPriority.java
C:\jeevesh>java ThreadPriority
Thread Name :My Thread 1
Thread Name :My Thread 2
Thread Priority :Thread[My Thread 2,10,main]
Thread Name :My Thread 2
Thread Priority :Thread[My Thread 2,10,main]
Thread Name :My Thread 2
Thread Priority :Thread[My Thread 2,10,main]
Thread Priority :Thread[My Thread 1,1,main]
Thread Name :My Thread 1
Thread Priority :Thread[My Thread 1,1,main]
Thread Name :My Thread 1
Thread Priority :Thread[My Thread 1,1,main]
• In this program two threads are created. We have set up maximum priority for the first
thread "MyThread2" and minimum priority for the first thread "MyThread1" i.e. the
after executing the program, the first thread is executed only once and the second
thread "MyThread2" started to run until either it gets end or another thread of the
equal priority gets ready to run state.
 Deadlock

• A situation where a thread is waiting for an

object lock that holds by second thread,
and this second thread is waiting for an
object lock that holds by first thread, this
situation is known as Deadlock.
 Deadlock contd…
• Lets see a situation in the diagram shown below where the deadlock
condition is occurred :
 Deadlock contd….
• In this diagram two threads having the
Printing & I/O operations respectively at a
time. But Thread1 need to printer that  is
hold up by the Thread2, likewise Thread2
need the keyboard that is hold up by the
Thread1. In this situation the CPU
becomes ideal and the deadlock condition
occurs because no one thread is executed
until the hold up resources are free. 
 Deadlock contd….
• The following program demonstrates the deadlock situation:
• public class DeadDemo{
  public static void main(String args[]){
  String s1="Dead";
  String s2="Lock";
  MyThread1 m=new MyThread1(s1,s2);
  MyThread2 m1=new MyThread2(s1,s2);
  }
}
class MyThread1 extends Thread{
  String s1;
  String s2;
  MyThread1(String s1, String s2){
  this.s1=s1;
  this.s2=s2;  
  start();
  }
  public void run(){
    while(true){
    synchronized(s1){
      synchronized(s2){
      System.out.println(s1+s2);    
      }
    }
    }
  }
}
class MyThread2 extends Thread{
  String s1;
  String s2;
  MyThread2(String s1,String s2){
  this.s1=s1;
  this.s2=s2;
    start();
  }
  public void run(){
    while(true){
    synchronized(s2){
    
      synchronized(s1){
      System.out.println(s2+s1);
      }
    }
    }
  }
}
 Deadlock contd ….
• O/P of the program is:
• C:\j2se6\thread>javac DeadDemo.java
C:\j2se6\thread>java DeadDemo
DeadLock
DeadLock
DeadLock
DeadLock
DeadLock
DeadLock
DeadLock
DeadLock
LockDead
LockDead
LockDead
LockDead
LockDead
LockDead
LockDead
DeadLock
DeadLock
DeadLock
DeadLock
DeadLock
DeadLock
DeadLock
.........
......... C:\j2se6\thread>
 Synchronized Threads

• In Java, the threads are executed

independently to each other. These types
of threads are called as asynchronous
threads.
 Synchronized Threads contd…
• In Java, the threads are executed independently to each
other. These types of threads are called as
asynchronous threads. But there are two problems
may be occur with asynchronous threads.
• Two or more threads share the same resource (variable
or method) while only one of them can access the
resource at one time.

• If the producer and the consumer are sharing the same

kind of data in a program then either producer may
produce the data faster or consumer may retrieve an
order of data and process it without its existing. 
 Synchronized Threads contd…
• Suppose, we have created two methods as
increment( ) and decrement( ). which increases
or decreases value of the variable "count"  by 1
respectively shown as:
• public void increment( ) {
        count++;
    }

    public void decrement( ) {

        count--;
    } public int value() { return count; }
• When the two threads are executed to access these methods (one for
increment( ),another for decrement( )) then both will share the variable "count". in
that case, we can't be sure that what value will be returned of variable "count". 
We can see this problem in the diagram shown below:
 Synchronization contd …
• To avoid this problem, Java uses monitor also known as “semaphore” to prevent
data from being corrupted by multiple threads by a keyword synchronized to
synchronize them and intercommunicate to each other. It is basically a mechanism
which allows two or more threads to share all the available resources in a sequential
manner. Java's synchronized is used to ensure that only one thread is in a critical
region. critical region is a lock area where only one thread is run (or lock) at a time.
Once the thread is in its critical section, no other thread can enter to that critical
region. In that case, another thread will has to wait until the current thread leaves its
critical section.
• General form of the synchronized statement is as:
• synchronized(object) { 

// statements to be synchronized 

}
 Synchronization contd …
Lock:
•  Lock term refers to the access granted to a particular thread that
can access the shared resources. At any given time, only one
thread can hold the lock and thereby have access to the shared
resource. Every object in Java has build-in lock that only comes in
action when the object has synchronized method code. By
associating a shared resource with a Java object and its lock, the
object can act as a guard, ensuring synchronized access to the
resource. Only one thread at a time can access the shared resource
guarded by the object lock.
• Since there is one lock per object, if one thread has acquired the
lock, no other thread can acquire the lock until the lock is not
released by first thread. Acquire the lock means the thread currently
in synchronized method and released the lock means exits the
synchronized method. 
 Synchronization And Lock
• Remember the following points related to lock and synchronization:
• Only methods (or blocks) can be synchronized, Classes and variable cannot be synchronized.
     
• Each object has just one lock.
    
• All methods in a class need not to be synchronized. A class can have both synchronized and non-synchronized
methods.
     
• If two threads wants to execute a synchronized method in a class, and both threads are using the same instance
of the class to invoke the method then only one thread can execute the method at a time.
     
• If a class has both synchronized and non-synchronized methods, multiple threads can still access the class's non-
synchronized methods. If you have methods that don't access the data you're trying to protect, then you don't
need to synchronize them. Synchronization can cause a hit in some cases (or even deadlock if used incorrectly),
so you should be careful not to overuse it.
    
• If a thread goes to sleep, it holds any locks it has—it doesn't release them.
    
• A thread can acquire more than one lock. For example, a thread can enter a synchronized method, thus acquiring
a lock, and then immediately invoke a synchronized method on a different object, thus acquiring that lock as well.
As the stack unwinds, locks are released again.
     
• You can synchronize a block of code rather than a method.
     
• Constructors cannot be synchronized
 Synchronization and Lock
• There are two ways to synchronized the execution of code:
• Synchronized Methods
     
• Synchronized Blocks (Statements)
• Synchronized Methods: 
• Any method is specified with the keyword synchronized  is only executed
by one thread at a time. If any thread want to execute the synchronized
method, firstly it has to obtain the objects lock.  If the lock is already held by
another thread, then calling thread has to wait.      
Synchronized methods are useful in those situations where methods are
executed concurrently, so that these can be intercommunicate manipulate
the state of an object in ways that can corrupt the state if . Stack
implementations usually define the two operations push and pop of
elements as synchronized, that’s why pushing and popping are mutually
exclusive operations. For Example if several threads were sharing a stack, if
one thread is popping the element on the stack then another thread would
not be able to pushing the element on the stack.
     
 Synchronization Program
• The following program demonstrates the synchronized method:
•  
• class Share extends Thread{
  static String msg[]={"This", "is", "a", "synchronized", "variable"};
  Share(String threadname){
    super(threadname);
  }
  public void run(){
    display(getName());
  }
  public synchronized void display(String threadN){
    for(int i=0;i<=4;i++)
      System.out.println(threadN+msg[i]);
      try{
      this.sleep(1000);
  }catch(Exception e){}
    }
}
public class SynThread1 {
  public static void main(String[] args)   {
    Share t1=new Share("Thread One: ");
    t1.start();
    Share t2=new Share("Thread Two: ");
    t2.start();
}
} Output of the program is:
• C:\nisha>javac SynThread.java
C:\nisha>java SynThread
Thread One: This
Thread One: is
Thread One: a
Thread One: synchronized
Thread One: variable
Thread Two: This
Thread Two: is
Thread two: a
Thread Two: synchronized
Thread Two: variable
 Synchronization Program
• In this program, the method "display( )" is
synchronized that will be shared by both
thread's objects at the time of program
execution. Thus only one thread can
access that method and process it until all
statements of the method are executed. 
Synchronization implementation
• Synchronized Blocks (Statements)
• Another way of  handling synchronization is
Synchronized Blocks (Statements). Synchronized
statements must specify the object that provides the
native lock. The synchronized block allows execution of
arbitrary code to be synchronized on the lock of an
arbitrary object.
• General form of synchronized block is:
• synchronized (object reference expression)
     {
// statements to be synchronized 
}
• The following program demonstrates the synchronized block that shows the same output as the output of the
previous example:
•  
• class Share extends Thread{
  static String msg[]={"This", "is", "a", "synchronized", "variable"};
  Share(String threadname){
    super(threadname);
  }
  public void run(){
    display(getName());
  }
  public void display(String threadN){
         synchronized(this){
    for(int i=0;i<=4;i++)
      System.out.println(threadN+msg[i]);
      try{
      this.sleep(1000);
  }catch(Exception e){}
    }
}
public class SynStatement {
  public static void main(String[] args)   {
    Share t1=new Share("Thread One: ");
    t1.start();
    Share t2=new Share("Thread Two: ");
    t2.start();
}
} Output of the Program
•  C:\nisha>javac SynStatement.java C:\nisha>java SynStatement
Thread One: This
Thread One: is
Thread One: a
Thread One: synchronized
Thread One: variable
Thread Two: This
Thread Two: is
Thread Two: a
Thread Two: synchronized
Thread Two: variable
 Inter-Thread Communication

• Java provides a very efficient way through which

multiple-threads can communicate with each-
other. This way reduces the CPU’s idle time i.e.
A process where, a thread is paused running in
its critical region and another thread is allowed
to enter (or lock) in the same critical section to
be executed.  This technique is known as
Interthread communication which is
implemented by some methods. These methods
are defined in "java.lang" package and can only
be called  within synchronized code shown as:
Inter-Thread Communication
 Inter-Thread Communication
• All these methods must be called within a try-catch block.
• Lets see an example implementing these methods :
• class Shared {
int num=0;
boolean value = false;
    
synchronized int get() {
  if (value==false) 
  try {
    wait();
    }
  catch (InterruptedException e) {
  System.out.println("InterruptedException caught");
    }
System.out.println("consume: " + num);
value=false;
notify();
return num;
}
 Inter-Thread Communication
• synchronized void put(int num) {
  if (value==true) 
  try {
    wait();
    }
  catch (InterruptedException e) {
  System.out.println("InterruptedException caught");
    }
    this.num=num;
    System.out.println("Produce: " + num);
    value=false;
    notify();
    }
    }
    class Producer extends Thread {
  Shared s;
  
  Producer(Shared s) {
    this.s=s;
    this.start();
  }
  public void run() {
    int i=0;
    
    s.put(++i);
    }
}
class Consumer extends Thread{
  Shared s;
  
  Consumer(Shared s) {
    this.s=s;
    this.start();
  }
  public void run() {
    s.get();
    }
}
public class InterThread{
  public static void main(String[] args) 
  {
    Shared s=new Shared();
    new Producer(s);
    new Consumer(s);
  }
}
 Inter-Thread Communication
• Output of the Program:
• C:\jeevesh>javac InterThread.java
C:\jeevesh>java InterThread
Produce: 1
consume: 1
• In this program, two threads "Producer" and "Consumer" share the
synchronized methods of the class "Shared". At time of program
execution, the "put( )" method is invoked through the "Producer"
class which increments the variable "num" by 1. After producing 1
by the producer, the method "get( )" is invoked by through the
"Consumer" class which retrieves the produced number and
returns it to the output. Thus the Consumer can't retrieve the
number without producing of it.
 Inter-Thread Communication
• Another program demonstrates the uses of wait() & notify() methods:

• public class DemoWait extends Thread{
  int val=20;
  public static void main(String args[])  {
    DemoWait d=new DemoWait();
    d.start();
    new Demo1(d);
  }
  public void run(){
    try    {
    synchronized(this){
    wait();
    System.out.println("value is  :"+val);    
    }
    }catch(Exception e){}
 }
  public void valchange(int val){    
    this.val=val;    
    try    {
    synchronized(this)    {
    notifyAll();   
    }
    }catch(Exception e){}
  }
}
 Inter-Thread Communication
• class Demo1 extends Thread{
  DemoWait d;
  Demo1(DemoWait d)  {
  this.d=d;
  start();
  }
  public void run(){
   try{
    System.out.println("Demo1 value is"+d.val);
    d.valchange(40);
  }catch(Exception e){}
  }
}
Inter-Thread Communication
• Output of the program is:
• C:\jeevesh\thread>javac DemoWait.java

C:\jeevesh\thread>java DemoWait
Demo1 value is20
value is :40

C:\jeevesh\thread>
 Daemon Threads

• In Java, any thread can be a Daemon thread. Daemon

threads are like a service providers for other threads or
objects running in the same process as the daemon
thread. Daemon threads are used for background
supporting tasks and are only needed while normal
threads are executing. If normal threads are not running
and remaining threads are daemon threads then the
interpreter exits.
• setDaemon(true/false) – This method is used to specify
that a thread is daemon thread.

       public boolean isDaemon() – This method is used

to determine the thread is daemon thread or not.
 Daemon Threads

• The following program demonstrates the Daemon Thread:

• public class DaemonThread extends Thread {
  public void run() {
    System.out.println("Entering run method");
    try {
      System.out.println("In run Method: currentThread() is"
          + Thread.currentThread());
      while (true) {
        try {
          Thread.sleep(500);
        } catch (InterruptedException x) {
        }
        System.out.println("In run method: woke up again");
      }
    } finally {
      System.out.println("Leaving run Method");
    }
  }
 Daemon Threads
• public static void main(String[] args) {
    System.out.println("Entering main Method");
    DaemonThread t = new DaemonThread();
    t.setDaemon(true);
    t.start();
    try {
      Thread.sleep(3000);
    } catch (InterruptedException x) {
    }
    System.out.println("Leaving main method");
  }
} Output of this program is:
• C:\jeevesh\thread>javac DaemonThread.java
C:\jeevesh\thread>java DaemonThread
Entering main Method
Entering run method
In run Method: currentThread() isThread[Thread-0,5,main]
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
Leaving main method
C:\jeevesh\thread>
 Thank you…
• Create multiple java threads for printing
tables from 2 to 10. Each thread for each
number. Table shall continue till number *
20, i.e. for e.g. 3*20=60 with thread names
as “Table for Number”.