java线程间通信
首先看一段代码
class Res
{
String name;
String sex;
}
class Input implements Runnable
{
private Res r; Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true){
if(x==0){
r.name = "mike";
r.sex = "male";
}
else{
r.name = "丽丽";
r.sex = "女";
}
x = (x+1) % 2;
}
}
} class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
System.out.println(r.name + "---" + r.sex);
}
}
} class Test
{
public static void main(String[] args)
{
Res r = new Res();
Input in = new Input(r);
Output out = new Output(r); Thread t1 = new Thread(in);
Thread t2 = new Thread(out); t1.start();
t2.start();
} }
上面的代码主要是想实现一个人名和姓别的同时输入和输出，但是看结果却是错乱不堪的。这个原因是由于是线程安全问题。
下面就代码中加入同步代码块。关键要注意到Input和Output都要加入，并且synchronized的对象必须是同一个，这个选取Res r = new Res(); 由这条语句创建的对象r比较好。下面是修改后的代码及结果。
class Res
{
String name;
String sex;
}
class Input implements Runnable
{
private Res r; Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true){
synchronized(r){
if(x==0){
r.name = "mike";
r.sex = "male";
}
else{
r.name = "丽丽";
r.sex = "女";
}
x = (x+1) % 2;
}
}
}
} class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
synchronized(r){
System.out.println(r.name + "---" + r.sex);
}
}
}
} class Test
{
public static void main(String[] args)
{
Res r = new Res();
Input in = new Input(r);
Output out = new Output(r); Thread t1 = new Thread(in);
Thread t2 = new Thread(out); t1.start();
t2.start();
} }
同步代码块保证线程安全运行，但是为什么会出现一直显示丽丽或者是mike呢？这是由于假如输入线程输入之后输出线程一直在执行，那么输出的就是相同的内容了，这肯定不是我们想要的，我们想要的是输入一组数据就输出一组数据，那么如何修改呢？其实我们加一个标记用于判断，当没有输入的时候不能取数据而只能存数据，当已经存入一组数据的时候只能取数据而不能存数据。
class Res
{
String name;
String sex;
boolean flag = false; //这里主要是一个标志，判断是否有输入，初始化为没有输入数据
}
class Input implements Runnable
{
private Res r; Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true){
synchronized(r){ //同步代码块
if(r.flag) //如果本身有数据就等待，并且通知其他线程取走数据
try{r.wait();}catch(Exception e){}//在这里其实会阻塞，不会往下执行
if(x==0){
r.name = "mike";
r.sex = "male";
}
else{
r.name = "丽丽";
r.sex = "女";
}
x = (x+1) % 2;
//到这里说明该线程阻塞后其他线程已经取走数据，并且告知该线程，该线程又可存数据
r.flag = true; //存数据之后标记为改变
try{r.notify();}catch(Exception e){}
}
}
}
} class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
synchronized(r){
if(!r.flag)//这里如果没有数据就会等待，有数据就会去取数据
try{r.wait();}catch(Exception e){}
System.out.println(r.name + "---" + r.sex);
r.flag = false;//取了数据就换标记位
try{r.notify();}catch(Exception e){}//然后通知其他线程
}
}
}
} class Test
{
public static void main(String[] args)
{
Res r = new Res();
Input in = new Input(r);
Output out = new Output(r); Thread t1 = new Thread(in);
Thread t2 = new Thread(out); t1.start();
t2.start();
} }
此时就会出现我们想要的结果，看看java api
可以看出wait(),notify(),等方法都用在同步中，因为要对持有锁的操作。所以这些方法要在同步中，只有同步才有锁！
为什么这些方法还会定义在Object中呢？
因为这些线程在操作同步线程时，都必须标识他们所操作线程的锁。只有同一个锁上被wait的线程才可以被同一个锁上的notify唤醒！也就是等待和唤醒必须是同一把锁，而锁可以是任意对象，而任意对象就定义在Object中！
现在对上面的代码进行优化。
class Res
{
private String name;
private String sex;
private boolean flag = false; //这里主要是一个标志，判断是否有输入，初始化为没有输入数据
public synchronized void set(String name,String sex){
if(flag) //如果本身有数据就等待，并且通知其他线程取走数据
try{this.wait();}catch(Exception e){}//在这里其实会阻塞，不会往下执行
this.name = name;
this.sex = sex;
flag = true; //存数据之后标记为改变
try{this.notify();}catch(Exception e){}
}
public synchronized void out(){
if(!flag)//这里如果没有数据就会等待，有数据就会去取数据
try{this.wait();}catch(Exception e){}
System.out.println(name + "---" + sex);
flag = false;//取了数据就换标记位
try{this.notify();}catch(Exception e){}//然后通知其他线程 }
}
class Input implements Runnable
{
private Res r;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true){
if(x==0)
r.set("mike","male");
else
r.set("丽丽","女");
x = (x+1) % 2;
}
}
}
class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out();
}
}
}
class Test
{
public static void main(String[] args)
{
Res r = new Res();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
} }
这次再来看一个生产消费者的例子。
class ProducerConsumer
{
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
t1.start();
t2.start();
}
} class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name){ //这里传入一个参数，生产一个商品
if(flag)
try{wait();}catch(Exception e){}
this.name = name + "----" + count++; //生产一个商品，进行计数
System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
flag = true;
this.notify();
}
public synchronized void out(){//消费一个商品
if(!flag)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"---消费者---"+this.name);
flag = false;
this.notify();
}
} class Producer implements Runnable
{
private Resource res;
Producer(Resource res){
this.res = res;
}
public void run(){
while(true){
res.set("+商品+");
}
}
} class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res){
this.res = res;
}
public void run(){
while(true){
res.out();
}
}
}
但是如果主函数的代码改为如下：
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
Thread t3 = new Thread(pro);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
这里就是有两个生产线程，有两个消费线程，那么会出现问题
这就是当出现多个线程的时候的问题，需要使用while()循环不断判断标记，而不能使用if进行单次判断。也就是要把set和out里面的if语句全部变为while。这个时候会发生全部等待的现象，这里需要使用notifyAll进行全部唤醒。上面的程序只需要修改一下的几个地方
public synchronized void set(String name){
while(flag)//(1)
try{wait();}catch(Exception e){}
this.name = name + "----" + count++;
System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
flag = true;
this.notifyAll();//(2)
}
public synchronized void out(){
while(!flag)//(3)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"---消费者--------"+this.name);
flag = false;
this.notifyAll();//(4)
}
记住:
当出现多个生产者线程和消费者线程时，必须使用while和notifyAll。
其实notifyAll唤醒了所有线程，这也不是我们的目的，我们只想唤醒对方线程，这该怎么做呢？
其实这需要看jdk1.5的新特性
仔细看这方面的资料，重新修改代码
import java.util.concurrent.locks.*;
class ProducerConsumer
{
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
Thread t3 = new Thread(pro);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
} class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition(); public void set(String name)throws InterruptedException{
lock.lock();//这里显示加锁
try {
while(flag)
condition.await();// == try{wait();}catch(Exception e){}
this.name = name + "----" + count++;
System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
flag = true;
condition.signalAll();// == this.notifyAll();如果使用signal则会出现等待现象
} finally {
lock.unlock();//这里显示解锁,必须执行，所以要放在这里
} }
public void out()throws InterruptedException{
lock.lock();//这里显示加锁
try {
while(!flag)
condition.await();// == try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"---消费者--------"+this.name);
flag = false;
condition.signalAll();// == this.notifyAll();如果使用signal则会出现等待现象
} finally {
lock.unlock();//这里显示解锁,必须执行，所以要放在这里
}
}
} class Producer implements Runnable
{
private Resource res;
Producer(Resource res){
this.res = res;
}
public void run(){
while(true){
try{res.set("+商品+");}catch(InterruptedException e){}
}
}
} class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res){
this.res = res;
}
public void run(){
while(true){
try{res.out();}catch(InterruptedException e){}
}
}
}
上面程序只是对上上一个程序的替代，只不过是用到了比价现代的做法，但是本质还是没变，没有达到我们的目的，就是唤醒线程只唤醒对方线程，简而言之，生产者线程唤醒消费者线程，消费者线程唤醒生产者线程。虽然上面的程序没有实现这个目标，不过他具有比较多的特性，现在只需要简单修改便可达到目的。
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();
private Condition condition_pro = lock.newCondition();
private Condition condition_con = lock.newCondition(); public void set(String name)throws InterruptedException{
lock.lock();
try {
while(flag)
condition_pro.await();// == try{wait();}catch(Exception e){}
this.name = name + "----" + count++;
System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
flag = true;
condition_con.signal();// == this.notifyAll();
} finally {
lock.unlock();
} }
public void out()throws InterruptedException{
lock.lock();
try {
while(!flag)
condition_con.await();// == try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"---消费者--------"+this.name);
flag = false;
condition_pro.signal();// == this.notifyAll();
} finally {
lock.unlock();
}
}
}
这里主要看注释的几行代码。他们达到了目的：生产者线程唤醒消费者线程，消费者线程唤醒生产者线程。lock可以支持多个相关的 Condition 对象。