JAVA——生产者与消费者以及JDK1.5以后新特性

生产者和消费者问题是很常见的一类多线程问题。问题大致描述为：

有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经放入产品的缓冲区中再次投放产品。当遇到多个生产者和消费者时候可能会出现一些问题。下面代码分析：

//创建资源类
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();
}
}
}

//测试类
class ProducerConsunmerDemo
{
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(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);

t1.start();
t2.start();
t3.start();
t4.start();

}
}

看到这里发现，生产者生产了两次，消费者才开始消费。

下面我们来分析一下：

t1,t2为生产者，t3,t4为消费者。当程序运行的时候：



一开始因为flag为false,所以生产者t1进行生产，然后flag = true;

这时t1又一次获取了cpu的执行权，因为此时flag=true,所以t1被wait了。

这时候t2获取了cpu的执行权,t2进来了，发现flag=true，也挂起来了。

这是t3获取了cpu的执行权，进来了输出。然后flag=false.然后唤醒了t1；

这时t3进来了，被挂起来了。t4进来也被挂起来了。t1这时候输出以后唤醒的是线程池中的t2，t2继续往下运行，不会判断flag的标志。

所以我们希望每次都可以判断一下flag,所以：



这是发现：



运行停止了这是因为都处于等待了；因为前面我们唤醒的有可能都是生产者或者都是消费者。

于是正常了：





总结：

1、对于多个生产者与消费者，为什么要用while判断标记？

因为要让被唤醒的线程再一次判断标记。

2、为什么定义notifyAll?

因为需要唤醒对方线程；因为只用notify却只能唤醒本方线程的情况。导致程序中的所有线程都等待。

下面看看JDK1.5以后的多线程升级解决方案。

将同步Synchronized替换为显示的Lock操作。将Object中的wait，notify, notifyAll替换了Condition对象。该对象可以通过Lock锁进行获取。该实例中，实现了本方只唤醒对方的操作。

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();
this.name = name+"------"+count++;
System.out.println(Thread.currentThread().getName()+"--生产者-"+this.name);
flag = true;
condition_con.signal();
}
finally
{
lock.unlock();  //释放锁的动作一定要执行
}
}
public void out() throws InterruptedException
{
try
{
lock.lock();
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"--------消费者--------"+this.name);
flag = false;
condition_pro.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 ProducerConsunmerDemo3
{
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(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}

这是一开始的单个Condition的情况：



这是多个Condition的情况：一个锁可以对应多个Condition.