【生产者消费者模型】实现wait()和notify() 实现阻塞队列

程序员面试多线程高频问题之生产者消费者模型。
这道题主要考察对线程通知机制的理解和应用

关键要点

• 利用wait和notify的机制，通知其他线程阻塞条件被打破（队列为空/队列已满）

代码实现

import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 阻塞队列可用于生产者消费者模型
 * 如果队列满了，那么生产者不能往队列添加数据，并且阻塞到队列有空间添加数据。
 * 如果队列为空，那么消费者不能消费数据并且阻塞到数据。
 * 实现阻塞队列的关键点是要利用锁的wait和notify功能
 */
public class BlockQueue<T> {
    // 队列，可以用list表示方便首尾添加和删除数据
    private LinkedList<T> list;
    private int length = 10;
    private final static Object lockPru = new Object();
    private final static Object lockCom = new Object();
    private AtomicInteger count;

    BlockQueue(int length){
        this.list = new LinkedList<T>();
        this.length = length;
        this.count = new AtomicInteger();
    }

    BlockQueue(){
        this.list = new LinkedList<T>();
        this.count = new AtomicInteger();
    }

    /**
     *  生产者 往队列添加数据
     * @param t 添加的数据
     * @throws InterruptedException
     */
    public void push(T t) throws InterruptedException {
        synchronized (lockPru){ // 生产者的锁
            // 队列满了，调用wait() 让自己阻塞。
            //此处使用循环而不是判断的原因是可以支持定时阻塞，一旦wait被唤醒后，队列还是满，那么会继续阻塞
            while (count.get() == length - 1){
                System.out.println("队列满了，阻塞，长度为：" + count.get());
                lockPru.wait();
            }
            System.out.println("往队列添加数据");
            list.addFirst(t);
            // 队列长度自增1
            count.incrementAndGet();
        }

        // 通知消费者的进行消费。
        if(count.get() > 0){
            synchronized (lockCom){
                System.out.println("队列中有数据了，长度为: " + count.get());
                lockCom.notifyAll();
            }
        }
    }

    /**
     * 消费者进行消费，整个过程跟生产者相似
     * @return 消费的数据
     * @throws InterruptedException
     */
    public T poll() throws InterruptedException {
        T t;
        synchronized (lockCom){
            while (count.get() == 0){
                System.out.println("队列为空，长度为: " + count.get());
                lockCom.wait();
            }
            t = list.poll();
            count.decrementAndGet();
        }

        if(count.get() < length){
            synchronized (lockPru){
                System.out.println("队列有空位了，长度为: " + count.get());
                lockPru.notifyAll();
            }
        }
        return t;
    }

    public int size(){
        return count.get();
    }

    public static void main(String[] args) throws InterruptedException {
        BlockQueue<Integer> blockQueue = new BlockQueue(3);
        blockQueue.push(1);
        blockQueue.poll();
        blockQueue.push(1);
        blockQueue.poll();
    }


}

要点：
上述是线程阻塞方式实现的队列阻塞，其实还可以使用自旋方式实现。
自旋方式就是使用一个全局可见的变量（volite修饰的）控制，如果为某个值就一直循环。通知进行消费/生产时就可以改变这个全局可见变量，跳出循环进行操作。