thread24 - wait和notify和notifyAll

package com.neutron.t18;

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;

/**
 * 写一个固定容量的同步容器，拥有put和get方法，以及getCount方法。
 * 能够支撑2个生产者线程，以及10个消费者线程的阻塞调用
 *
 * 所谓同步容器，即如果容量满了，那么put阻塞；如果容量空了，那么get阻塞等待。
 * 使用wait和notify/notifyAll来实现
 */
public class T181<T> {
    // 同步容器
    private final LinkedList<T> lists = new LinkedList<>();
    // 容器最大容量
    private final int MAX = 10;
    // 容器数据个数计数器，个人认为加上volatile效果更好
    private /*volatile*/ int count = 0;

    public synchronized void put(T t) {
        /*
           思考：此处为何不使用if，而使用while呢？
           如果使用if的话，那么当this.wait被唤醒，那么继续执行下去，lists.add(t)
           会存在问题：此时其他线程如果已经写入数据，此时list的size等于10，如果继续执行下去那么数据个数会变成11
           而如果使用while，则不会存在这个问题，当线程被唤醒，需要继续判断条件是否需要继续去等待，
           如果其他线程已经写入数据，那么不会继续写入数据
         */
        while (lists.size() == MAX) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lists.add(t);
        System.out.println("put : " + t);
        count++;
        /**
         *  问题：通知消费者线程去消费,思考为什么不是notify而是notifyAll
         *  如果使用notify，那么被唤醒的线程可能是生产者线程，就会导致生产者继续等待，而整个程序处于等待状态，不会做任何操作
         *  但是如果notifyAll唤醒的就是生产者线程呢？如何处理呢？
         */
        this.notifyAll();
    }

    public synchronized T get() {
        T t;
        while (lists.size() == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t = lists.removeFirst();
        System.out.println("get : " + t);
        count--;
        this.notifyAll();   // 通知消费者线程去消费
        return t;
    }

    public static void main(String[] args) {
        T181<String> r1 = new T181();
        // 创建10个消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) {
                    r1.get();
                }
            }).start();
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 创建2个生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) {
                    r1.put(Thread.currentThread().getName() + " "+ j);
                }
            }, "p" + i).start();
        }
    }
}