synchronization -instance_of_java

1. instanceofjavaforus.blogspot.in http://instanceofjavaforus.blogspot.in/2014/10/synchronization.html
Synchronization ~ Instance Of Java
What is Synchronization?
The concept of avoiding multiple threads entering into a common functionality of common object
simultaneously is known as thread safe or synchronization.
we implement the concept of thread safe using synchronized keyword. The functionality of Synchronized
keyword is to avoid multiple threads entering into a common functionality of common functionality.
Why do we need Synchronization?
The "Synchronized" keywords prevents concurrent access to a block of code or object by multiple Threads.
Synchronized keyword in Java provides locking, which ensures mutual exclusive access of shared resource
and prevent data race.
To prevent consistency problem and thread interference .
Producer consumer problem:
Common class:
package com.instanceofjavaforus;
public class Common {
int x;
boolean flag=true;
//if flag is true producer thread has to produce
// if flag is false consumer thread has to produce
synchronized public void produce(int i){
if(flag){
x=i;
System.out.println("producer thread has produced "+i);
flag=false;
notify();
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

2. synchronized public int consume(){
if(flag){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
flag=true;
notify();
return x;
}
}
package com.instanceofjavaforus;
public class ProducerThread extends Thread {
Common c;
ProducerThread(Common c){
this.c=c;
}
public void run(){
int i=0;
while(true){
i++;
c.produce(i);
try {
Thread.sleep(600);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
ConsumerThread:
package com.instanceofjavaforus;
public class ConsumerThread extends Thread {
Common c;

3. ConsumerThread(Common c){
this.c=c;
}
public void run(){
while(true){
int x=c.consume();
System.out.println("Consumer consumes"+x);
try {
Thread.sleep(600);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
ProducerConsumerTest:
package com.instanceofjavaforus;
public class ProducerConsumerTest {
public static void main(String args[]){
Common c= new Common();
ProducerThread pt=new ProducerThread(c);
ConsumerThread ct= new ConsumerThread(c);
pt.start();
ct.start();
}
}
Output:
producer thread has produced 1
Consumer consumed 1
producer thread has produced 2
Consumer consumed 2
producer thread has produced 3
Consumer consumed 3
producer thread has produced 4
Consumer consumed 4
producer thread has produced 5
Consumer consumed 5
producer thread has produced 6
Consumer consumed 6