JAVA--多线程生产者消费者问题详解

最近学到多线程了，之前在网上看了很多博客，解释的都不怎么详细，对于新手来说确实比较难懂，所以我就来分享一下自己的理解，希望能够帮助到需要的人。

首先，来解释一下线程间的通信：就是多个线程执行的任务不同，但是操作的数据相同。我们需要线程同步的执行，这时要用到同一把锁，锁可以是任意的对象，这就是wait(),notify(),notifyAll()方法在Object里而不是在Thread里的原因了，这些方法必须用在同步中，因为同步中才有锁。在这里，资源类的对象就可以作为锁。不多说，先看看单个生产者和单个消费者的代码。

一.单个生产者和单个消费者

class Product
{
private String name;
private int count;
private boolean flag; //标志
//生产功能
public synchronized void product(String name){
if(flag)
try{this.wait();}catch(InterruptedException e){e.printStackTrace();}
this.name = name+"...."+count;
System.out.println(Thread.currentThread().getName()+"生产了"+this.name);
count++;
flag = true;
this.notify();
}
//消费功能
public synchronized void consume(){
if(!flag)
try{this.wait();}catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+"消费了"+name);
flag = false;
this.notify();
}
}
//生产者类
class Productor implements Runnable
{
private Product product;
Productor(Product product){
this.product = product;
}
public void run(){
while(true){
product.product("笔记本电脑");
}
}

}
//消费者类
class Consumer implements Runnable
{
private Product product;
Consumer(Product product){
this.product = product;
}
public void run(){
while(true){
product.consume();
}
}
}
class Pro_Con
{
public static void main(String[] args)
{
Product product = new Product();
Productor productor = new Productor(product);
Consumer consumer = new Consumer(product);
new Thread(productor).start();//一个生产线程
new Thread(consumer).start();//一个消费线程
}
}

this.wait() 指明持有哪个锁的线程去等待，让线程等待（会放弃锁），把线程放入了线程池.

this.notify() 唤醒线程池中的任意一个线程

这里用到的是synchronized来进行同步，当标志位为true时，等待并释放锁；当标志位为false时生产者生产一个，标志位置为true,唤醒消费者线程。

二.多个生产者和多个消费者（PS:生产单个，消费单个）

当有多个生产者和消费者时，我们上面的代码就不安全了，会发生生产者生产了两个，消费者消费一个或生产一个，消费两个的情况。我来简单分析下：

生产者1：抢到CPU资源，判断flag为false，生产一个，标志位置为true，空唤醒，再判断，为true，进入等待状态

生产者2：抢到CPU资源，进入，发现flag已经被设为true了，进入等待状态。

消费者1：抢到CPU资源，判断flag为true,消费一个，标记为置flase,如果唤醒的是生产者1。生产者一判断为false，生产一个，标记位置为true。

这时，如果唤醒的如果是生产者2，生产者2不会再判断，直接执行下面的代码，这时就会出现生产两个，消费一个的情况。

那该怎么解决呢？？？

要让它重新判断，把判断语句if(),改为while()就行了 ，但是会产生死锁，原因是当唤醒的是本方线程时会导致所有线程都等待。因为notify唤醒的是任意一个线程，不能保证唤醒的是对方线程，所以使用notifyAll()唤醒所有线程。

//生产功能
public synchronized void product(String name){
while(flag)//此处
try{this.wait();}catch(InterruptedException e){e.printStackTrace();}
this.name = name+"...."+count;
System.out.println(Thread.currentThread().getName()+"生产了"+this.name);
count++;
flag = true;
this.notifyAll();//此处
}

//消费功能
public synchronized void consume(){
while(!flag) //此处
try{this.wait();}catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+"消费了"+name);
flag = false;
this.notifyAll();//此处
}

三.使用Lock和Condition接口替代synchronized（优化程序性能）

上一个例子使用了notifyAll()方法解决了死锁的问题，但是每次都唤醒所有的线程会使程序的性能降低。JDK1.5之后对锁进行了单独描述，使用的接口Lock替代synchronized的方式：

·创建一把锁，也就是创建Lokc的子类对象

·把需要同步的代码放在lock（）和unlock（）之间

·Lock lock = new ReentrantLock();

Condition condition = lock.newCondition()

获取和锁绑定的condition对象

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Product
{
private String name;
private int count;
private boolean flag;
//创建一个锁对象
private Lock lock = new ReentrantLock();
//获取和锁绑定的生产者condition对象
private Condition pro = lock.newCondition();
//获取和锁绑定的消费者condition对象
private Condition con = lock.newCondition();

//生产功能，注意：synchronized已经被替代了
public void product(String name){
lock.lock(); //获取锁
try{
while(flag)
try{pro.await();}catch(InterruptedException e){e.printStackTrace();}
this.name = name+"...."+count;
System.out.println(Thread.currentThread().getName()+"生产了"+this.name);
count++;
flag = true;
con.signal();
}finally{
lock.unlock();//释放锁，因为要释放锁，所以放在finally中
}
}

//消费功能
public void consume(){
lock.lock();
try{
while(!flag)
try{con.await();}catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+"消费了"+name);
flag = false;
pro.signal();
}finally{
lock.unlock();
}
}
}

Condition中的await()等待，signal()唤醒线程池中任意一个，有JVM决定，signalAll()唤醒线程池中所有线程。

注：后两个代码只是部分，其他代码参考第一个。

四.多个生产者和多个消费者（PS:生产多个，消费多个）

//使用 jdk1.5的Lock,Condition实现可以同时生产多个，消费多个的功能
import java.util.concurrent.locks.*;
class Clothes
{
//产品的名称
private String name;
//产品的价格
private double price;
//存储产品的容器
private Clothes[] arr = new Clothes[100];
//定义一把锁
private Lock lock = new ReentrantLock();
//操作生产线程的Condition对象
private Condition pro = lock.newCondition();
//操作消费线程的Condition对象
private Condition con = lock.newCondition();
//生产线程和消费线程使用的下标以及产品数量
private int proindex,conindex,count;

public Clothes(){}
public Clothes(String name,double price)
{
this.name = name;
this.price = price;
}
public String toString()
{
return name+","+price;
}
//生产功能
public void produce()
{
lock.lock();
try
{
//当容器满的时候就不能生产
while(arr.length==count)
{
try{pro.await();}catch(InterruptedException e){e.printStackTrace();}
}
arr[proindex] = new Clothes("衬衫",9.99);
System.out.println(Thread.currentThread().getName()+"生产了..."+arr[proindex]);
//判断下标加1后是否和数组长度相同，相同则置为0
if(++proindex==arr.length)
proindex = 0;
//数量加1
count++;
con.signal();//唤醒一个消费线程
}
finally
{
lock.unlock();
}
}
//消费功能
public void consume()
{
lock.lock();
try
{
//当count为0的时候不能消费
while(count==0)
try{con.await();}catch(InterruptedException e){e.printStackTrace();}
//消费一件产品
Clothes yifu = arr[conindex];
System.out.println(Thread.currentThread().getName()+"消费了........"+yifu);
if(++conindex==arr.length)
conindex = 0;
//数量减1
count--;
pro.signal();

}
finally
{
lock.unlock();
}
}
}
//生产任务
class Producer implements Runnable
{
private  Clothes clo;
public Producer(Clothes clo)
{
this.clo = clo;
}
public void run()
{
while(true)
{
clo.produce();
}
}
}
//消费任务
class Consumer implements Runnable
{
private  Clothes clo;
public Consumer(Clothes clo)
{
this.clo = clo;
}
public void run()
{
while(true)
{
clo.consume();
}
}
}
class Demo7
{
public static void main(String[] args)
{
Clothes clo = new Clothes();

Producer producer = new Producer(clo);
Consumer consumer = new Consumer(clo);

Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer);

Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer);

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

}
}

多个生产者和多个消费者–生产和消费多个与生产和消费单个并没有什么区别，只是加了个容器–数组，将生产的产品存起来，而不是生产一个消费一个。把判断条件改变下就行了，容器满了，生产者不能生产；容器空了，消费者不能消费，仅此而已。