java多线程学习生产者消费者

上一篇博客主要学习了线程安全问题，以及简单的线程等待唤醒机制。这篇博客，基于上一篇的基础之上学习”生产者和消费者”，如果我有这样一个需求，即没生产一个商品就将其消费掉。

资源类

先看下Resource.java

package com.test.product.consumer;

public class Resource {

    private String name;
    private int count = 1;  //用来标志当前资源的id
    private boolean flag = false; //标志当前线程是否可以被唤醒
    public synchronized void setName(String name) {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name + "=="+count++;
        System.out.println(Thread.currentThread().getName()+"===生产了"+this.name);
        flag = true;
        this.notify();
    }


    public synchronized void get() {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"===========消费了"+this.name);
        flag = false;
        this.notify();
    }
}

如果你看过了java多线程学习，这里无需多说了。生产和消费都是在同一个资源类里，并且这里每生产一个和消费一个，我们都将其打印出来。这里在操作共享数据的方法前加上synchronized关键字，用来保证线程安全问题，使用flag保证当前线程是否需要等待以及是否可以唤醒其他线程。

生产者消费者

生产者

package com.test.product.consumer;
/**
 * 生成者  不断的生成商品
 * @author admin
 *
 */
public class Product implements Runnable{
    private Resource resource;


    public Product(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {

        while (true) {
            resource.setName("produce");
        }
    }
}

消费者

package com.test.product.consumer;

/**
 * 消费者 不断的消费商品
 * @author admin
 *
 */
public class Consumer implements Runnable{
    private Resource resource;


    public Consumer(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {

        while (true) {
            resource.get();
        }

    }

}

测试生产者消费者

Resource resource = new Resource();

        Product product = new Product(resource);
        Consumer consumer = new Consumer(resource);
        Thread t1 = new Thread(product);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();

这里生产者没生产一个商品，就唤醒消费者线程来消费，自己则处于等待状态，当消费者消费完成该商品，则唤醒生产者继续生产，此时消费者则处于等待状态。运行效果：

可以看到此时生产者每生产一个商品，就会被消费者消费掉。

遇到的问题

上面虽然完成了一个简单的生产者消费者的案例，但是还存在一下问题，就是现实生活中可能有很多的生产者用来生产，很多的消费者来完成消费，那么此时如果我在增加一个生产者和消费者：

Resource resource = new Resource();

        Product product = new Product(resource);
        Consumer consumer = new Consumer(resource);
        Thread t1 = new Thread(product);
        Thread t2 = new Thread(product);
        Thread t3 = new Thread(product);
        Thread t4 = new Thread(consumer);
        Thread t5 = new Thread(consumer);
        Thread t6 = new Thread(consumer);

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

此时运行效果如下：

可以看到会出现生产者只生产了一个produce，然而消费者却消费了两次，这显然是不对的。这是因为由于使用的是if判断是否需要等待，导致有的生产者或者消费者被唤醒以后没有运行该wait语句，所以我们需要将if改为while即可。

此时再次运行：

此时虽然可以实现”没生产一个消费一个的要求”，可是会发现，所有的线程都将处于等待状态，此时只需要将notify方法，改为notifyAll即可。

小结

• 对于多个生产者和消费者，使用while来作为判断标记是因为需要让被唤醒的线程在做一次标记的判断
• 使用notifyAll方法唤醒线程，是因为需要唤醒对方的线程，防止程序中所有的线程都处于等待状态。

Lock，Condition替换synchronized

上面的代码有一个问题，就是我们为了避免所有的线程都处于等待的状态，使用了notifyAll方法来唤醒所有的线程，如果我需要只是唤醒对方的线程，比如：生产者只能唤醒消费者的线程，消费者只能唤醒生产者的线程。
在jdk1.5当中为我们提供了多线程的升级解决方案：
1. 将同步synchronized替换成了Lock操作
2. 将Object中的wait，notify，notifyAll方法替换成了Condition对象
3. 可以只唤醒对方的线程
使用Lock方式修改后的Resource.java：

package com.five.product.consumer;

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

public class Resource {

    private String name;
    private int count = 1;  //用来标志当前资源的id
    private boolean flag = false; //标志当前线程是否可以被唤醒

    private Lock lock = new ReentrantLock();
    private Condition condition_pro = lock.newCondition(); //生产者
    private Condition condition_con = lock.newCondition(); //消费者

    public void setName(String name) throws InterruptedException {
        try {
            lock.lock();
            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 get() 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();
        }
    }
}

ok，关于生产者和消费者的学习就到这里了。

源码下载