简单记录一下，锁机制实现的P-C模型，原理看一遍代码就清楚了。

说句实话，

我们和大师的区别就是，编程大师们在没有参考的情况下能凭空构思出自己的解决方案，

并且还很完美，而我们只能在看完前辈的解决方案后才能恍然大悟，原来可以这么干，

第一个踩出路的人真的很厉害，我等凡人自愧不如

哈哈哈，废话真多。

这里使用Java内置锁synchronized实现，

主要就是利用wait()/notify()实现取/放两个操作的相互等待和通知，

容器为空，就wait阻塞住等待有元素加入时通知唤醒，队列满时也是如此。

用JDK提供的Lock锁也同样可以实现，步骤都差不多，就换一套API罢了。

import java.util.LinkedList;

class BlockingContainer<T> {
    private Object notFullLock = new Object();
    private Object notNullLock = new Object();
    private int capacity;
    private LinkedList<T> container = new LinkedList<T>();

    public BlockingContainer(int capacity) {
        this.capacity = capacity;
    }

    public T get() {
        while (container.size() == 0) {
            synchronized (notNullLock) {
                try {
                    notNullLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        T data = container.poll();
        --capacity;
        synchronized (notFullLock) {
            notFullLock.notify();
        }
        return data;
    }

    public boolean set(T value) {
        while (container.size() == capacity) {
            synchronized (notFullLock) {
                try {
                    notFullLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        boolean result = container.add(value);
        ++capacity;
        synchronized (notNullLock) {
            notNullLock.notify();
        }
        return result;
    }
}

public class Main {

    public static void main(String[] args) {
        BlockingContainer<String> bc = new BlockingContainer<>(5);
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "尝试获取");
            System.out.println(Thread.currentThread().getName() + "获取了一个元素：" + bc.get());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "设置了一个元素，状态：" + bc.set("test1"));
        }).start();
        new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "设置了一个元素，状态：" + bc.set("test2"));
            System.out.println(Thread.currentThread().getName() + "尝试获取");
            System.out.println(Thread.currentThread().getName() + "获取了一个元素：" + bc.get());
        }).start();
    }
}

输出：

Thread-0尝试获取
Thread-1设置了一个元素，状态：true
Thread-1尝试获取
Thread-0获取了一个元素：test2
Thread-0设置了一个元素，状态：true
Thread-1获取了一个元素：test1