Tag: Thread

Executer is a concept evolved from the world of Runnable interface. We have seen that how to create a thread using Runnable interface, extending thread and anonymous classes.

To run the task by implementing Runnable interface, we must have to create the object of the Thread like new thread(RunnableObject).start().  But we know that creating thread have its own overheads and stored in Stack and Heap memory. It’s very expensive to create a thread object just only to run the task in separate thread.

Executors framework (java.util.concurrent.Executor), released by the JAVA 5 in package java.util.concurrent is used to run the Runnable thread objects without creating the Thread object.

The Executor framework is a framework for standardizing invocation, scheduling, execution, and control of asynchronous tasks according to a set of execution policies.

There are three types of implementations provided by the Java:

1. ExecutorService
2. ThreadPoolExecutor
3. Executors (A Class containing factory methods)

To read documentation of Executor framework, refer this URL:
http://download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/Executor.html

In java we have two types of Threads: Daemon Thread and User Threads. Generally all threads created by programmer are user thread (unless you specify it to be daemon or your parent thread is a daemon thread).

User thread is generally meant to run our program code. JVM doesn’t terminate unless all the user thread terminate.
On the other hand we have Daemon threads. Typically these threads are service provider threads. They should not be used to run your program code but some system code. These threads run parallel to your code but survive on the mercy of the JVM. When JVM finds no user threads it stops and all daemon thread terminate instantly. Thus one should never rely on daemon code to perform any program code.

Synchronization, Producer and Consumer Problem, wait(), notify() methods of the Thread

class Controller
{
  private int counter;

  public void set(int i)
  {
      counter=i;
  }

  public int get()
  {
    return counter;
  }
}

class Producer extends Thread
{
  private Controller obj;

 public Producer(Controller c)
 {
  Obj=c;
 }

public void run()
{
 for(int i=0;I<5;i++ )
 {
   obj.set(i);
   System.out.println("put:"+j);
 }
}
}

class Consumer extends Thread
{
  private  Controller obj;

  public Consumer(Controller c)
  {
    obj=c;
  }

  public void run()
  {
    for(int  i=0;i<5;i++)
    {
        System.out.println("get:"+obj.get());
     }
  }
}

class TestSynchronization
{
 public  static void main(String args[])
 {
   Controller ctrl=new Controller;
   Producer thread1=new producer(ctrl);
   Consumer thread2=new Consumer(ctrl);
   thread1.start();
   thread2.start();
  }
}

O/P:-

put:0
get:0
get:0
get:0
get:0
get:0
put:1
put:2
put:3
put:4

Explanation:

In above program the producer creates value faster or slower than consumer that means there is no synchronization & this problem is known as producer_consumer problem.

Solution Of Producer & Customer Problem:-

Synchronized:

The synchronized block or synchronized method, allow only one thread at a time to execute.

Wait():

This method will cause the current thread to go into wait state until & unless notify() or notifyAll() is not called.

notifyAll():

It will give signal to all the threads which are in state to continue.

class Controller
{
  private int counter;
  private Boolean available=false;
  public synchronized int get()
  {
      while(available==false)
     {
      try
        {
          wait();
        }
        catch(Exception e)
        {
        }
     }
     notifyAll();
    available=false;
    return counter;
  }

 public synchronized int set(int value)
 {
   while(available==true)
   {
     try
     {
        wait();
     }
     catch(Exception e)
     {
     }
     counter=value;
     available=false;
     notifyAll();
    }
  }
}

class Producer extends Thread
{
  private Controller obj;
  public Producer(Controller c)
  {
   Obj=c;
  }

  public void run()
  {
   for(int i=0;I<5;i++ )
   {
     obj.set(i);
     System.out.println("put:"+j);
   }
 }
}

class Consumer extends Thread
{
 private  Controller obj;
 public Consumer(Controller c)
 {
  obj=c;
 }
 public void run()
 {
  for(int  i=0;i<5;i++)
  {
     System.out.println("get:"+obj.get());
  }
 }
}

class TestSynchronization
 {
  public  static void main(String args[])
  {
     Controller ctrl=new Controller;
     Producer thread1=new producer(ctrl);
     Consumer thread2=new Consumer(ctrl);
     thread1.start();
     thread2.start();
   }
}

O/P:
put:0
get:0
put:1
get:1
put:2
get:2
put:3
get:3
put:4
get:4