java: 线程间通信经典模型“生产者-消费者”模型的实现

安利一个网站：在线文档 jdk 1.6

---

一篇有参考价值的关于锁对象使用的博文：ReadLock和WriteLock(读写锁)

---

• java 对于多线程的控制提供了很多操作对象，方法。比如synchronized关键字，还有Object#wait() & Object#notify() & Object#notifyAll();
• 不过java还提供了一些其他的工具类，比如Lock & ReentrantLock & ReentrantReadWriteLock & Condition
  
  • 理论上，后面这套机制完全可以取代前面的那一套。
• 基于Lock & ReentrantLock & ReentrantReadWriteLock & Condition这些工具，我实现了一个简单的“生产者-消费者”模型。

核心代码如下：

package com.cat.multi.compete;

import java.awt.image.LookupOp;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.*;

/**
 * Created by cat on 2018/1/21.
 * 实现模型：
 * <p>
 * 生产者一直生产，直到产品数量达到 N， 就停止生产。
 * <p>
 * 并且，当产品到达 N 的时候，生产者要通知消费者来消费。
 * 同时：
 * <p>
 * 消费者一直消费，直到产品数量为0，就停止消费。
 * <p>
 * 并且，当没有产品的时候，消费者要通知生产者继续生产；
 * <p>
 * 基于多线程的，可以有任意多个生产者，以及任意多个消费者，不限制两个群体的数量。
 * <p>
 * -------------------------------------
 */
public class Repertory<T> {

    private static final int MIN_MAX = 10;
    private static final int SLEEP = 100;
    private static final boolean DEBUG = false;
    private static final boolean Loggable = false;
    private static final boolean LIMIT = false;


    private final Condition putCondition;
    private final Condition takeCondition;

    private List<T> itemList;
    private int max;

    private ReentrantReadWriteLock.WriteLock writeLock;
    private ReentrantReadWriteLock.ReadLock readLock;

    public Repertory() {
        this(MIN_MAX);
    }

    public Repertory(int max) {
        // init collection
        if (max < MIN_MAX) {
            max = MIN_MAX;
        }
        this.max = max;
        if (LIMIT) {
            this.max = 1;
        }
        itemList = new LinkedList<>();
        // init rwLock
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        writeLock = rwLock.writeLock();
        readLock = rwLock.readLock();
        putCondition = writeLock.newCondition();
        takeCondition = writeLock.newCondition();
    }

    private boolean isEmpty() {
        return this.itemList.size() == 0;
    }

    private boolean isFull() {
        return this.itemList.size() == max;
    }

    private boolean needPut() {
        if (LIMIT) {
            return isEmpty();
        }
        return isEmpty() || itemList.size() <= max / 5;
    }

    private boolean needTake() {
        if (LIMIT) {
            return isFull();
        }
        return isFull() || itemList.size() > max * 4 / 5;
    }

    private void checkAccess() {
        if (needPut() && needTake()) {
            throw new RuntimeException("判断条件出错，必须修改程序...");
        }
    }

    /**
     * 该方法只应该被【生产者】线程调用，否则容易出现死锁
     *
     * @param obj 生产的对象
     * @throws InterruptedException 中断异常
     */
    public void put(T obj) throws InterruptedException {

        writeLock.lock();
        try {
            checkAccess();
            while (needTake()) {
                takeCondition.signalAll();
                putCondition.await(); // 满了，就等待，并通知消费者取货
            }
            if (DEBUG || LIMIT) {
                Thread.sleep(SLEEP);
            }
            itemList.add(obj);
            if (DEBUG || Loggable) {
                System.out.println(Thread.currentThread().getName() + "-put--" + obj);
            }
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 该方法只应该被【消费者】线程调用，否则容易出现死锁
     *
     * @throws InterruptedException 中断异常
     */
    public void take() throws InterruptedException {
        writeLock.lock();
        try {
            checkAccess();
            while (needPut()) {
                putCondition.signalAll(); // TODO:这里要注意，一定要先去唤醒对象，然后再让自己休息！，
                takeCondition.await(); // 否则，自己休息了，也就没有机会唤醒对方了...
            }
            if (DEBUG || LIMIT) {
                Thread.sleep(SLEEP);
            }
            T obj = itemList.remove(0);
            if (DEBUG || Loggable) {
                System.out.println(Thread.currentThread().getName() + "-take--" + obj);
            }
        } finally {
            writeLock.unlock();
        }
    }

    public void show() {
        readLock.lock();
        try {
            System.err.println("SHOW ### " + this.toString());
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public String toString() {
        String msg = "";
        if (DEBUG || Loggable || itemList.size() < MIN_MAX) {
            msg = "Repertory{" +
                    "max=" + max +
                    " , length=" + itemList.size() +
                    " , itemList=" + itemList +
                    '}';
        } else {
            msg = "Repertory{" +
                    "max=" + max +
                    " , length=" + itemList.size() +
                    " , itemList=" + itemList.hashCode() +
                    '}';
        }
        return msg;
    }
}

在这里，我设计了一个弹性的提醒机制：当产品数量不多的时候，就取提醒生产者继续生产，当产品快要填满仓库的时候，提醒消费者去消费产品。

主要是要注意Lock和Condition的使用。什么时候去唤醒对象，什么时候去锁住自己。

贴一下运行效果：

main....done
SHOW ### Repertory{max=800 , length=160 , itemList=-1860611849}
SHOW ### Repertory{max=800 , length=160 , itemList=-1298639763}
SHOW ### Repertory{max=800 , length=160 , itemList=2000215250}
SHOW ### Repertory{max=800 , length=641 , itemList=-1309744438}
SHOW ### Repertory{max=800 , length=540 , itemList=1941569576}
SHOW ### Repertory{max=800 , length=641 , itemList=-1381681245}
SHOW ### Repertory{max=800 , length=583 , itemList=-452614553}
SHOW ### Repertory{max=800 , length=584 , itemList=861488929}
SHOW ### Repertory{max=800 , length=403 , itemList=96019575}
SHOW ### Repertory{max=800 , length=630 , itemList=1046072484}
SHOW ### Repertory{max=800 , length=641 , itemList=-1165811446}
SHOW ### Repertory{max=800 , length=516 , itemList=1904956760}
SHOW ### Repertory{max=800 , length=641 , itemList=-1900689143}
SHOW ### Repertory{max=800 , length=641 , itemList=361414021}
SHOW ### Repertory{max=800 , length=160 , itemList=-556965428}
SHOW ### Repertory{max=800 , length=160 , itemList=-1430830115}
SHOW ### Repertory{max=800 , length=160 , itemList=-1057490965}
SHOW ### Repertory{max=800 , length=542 , itemList=-523711472}
SHOW ### Repertory{max=800 , length=160 , itemList=1731272543}
SHOW ### Repertory{max=800 , length=269 , itemList=-1022961313}
SHOW ### Repertory{max=800 , length=638 , itemList=1221651327}
SHOW ### Repertory{max=800 , length=641 , itemList=1042805193}
SHOW ### Repertory{max=800 , length=160 , itemList=-1602343791}
SHOW ### Repertory{max=800 , length=535 , itemList=-1074051187}
SHOW ### Repertory{max=800 , length=614 , itemList=130345902}
SHOW ### Repertory{max=800 , length=160 , itemList=1746308531}
SHOW ### Repertory{max=800 , length=160 , itemList=454520929}
SHOW ### Repertory{max=800 , length=641 , itemList=-1199120192}
SHOW ### Repertory{max=800 , length=160 , itemList=1381613569}
SHOW ### Repertory{max=800 , length=160 , itemList=-249456061}
SHOW ### Repertory{max=800 , length=353 , itemList=-503794141}

Process finished with exit code 130 (interrupted by signal 2: SIGINT)

从log上面大致可以看到，设计的最大值是800，然后生产者和消费在间歇作业，只要满足等待条件，就唤醒对方，并自己休息。

完整源码：可以在彩蛋里面拿到。~