Java wait和notifyAll的使用，简单的阻塞队列实现

wait，会使调用的线程进入等待状态，会释放所持有的对象锁（调用的时候也必须先获取到锁，否则会抛出异常 IllegalMonitorStateException）

notifyAll、notify，会去唤醒应当前对象而等待的线程，（调用的时候也必须先获取到锁，否则会抛出异常 IllegalMonitorStateException）

顺便也记录一下join方法，调用join方法，会使当前线程进入等待，如果没有设置等待时间，就会等待另一个线程执行完成才返回（ps:调用join方法并不一定立刻执行另一个线程，只是当前线程进入等待，然后切换下一个线程）

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author lhd
 */
public class BlockQueue {

    /**
     * 生产者锁对象
     */
    private final Object addLock = new Object();

    /**
     * 消费者锁对象
     */
    private final Object deleteLock = new Object();

    /**
     * 队列总大小
     */
    private final Integer size = 30;

    /**
     * 数据存放
     */
    private Object[] queue = new Object[size];

    /**
     * 存放的数量,使用AtomicInteger是因为普通的int递增递减操作会存在非原子性的问题，会使数量异常
     */
    private AtomicInteger count = new AtomicInteger(0);

    /**
     * 生产
     * @param o 对象
     */
    public void add(Object o) {
        //获取生产锁,wait方法必须获取到对象锁后才可以调用，否则抛出异常
        synchronized (addLock){

            //判断是否超过队列大小,超过则进入等待
            while (count.get() >= size){
                try {
                    addLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //存放一个
            queue[count.get()] = o;
            //递增
            int i = count.incrementAndGet();
            //打印一下日志
            String name = Thread.currentThread().getName();
            System.out.println(name + "生产了一个，现有数量" + i);
        }
        //如果队列有数据，则调用notifyAll唤醒消费者
        if (count.get() >= 1){
            //notifyAll、notify都需要先获取对象锁,否则会抛出异常
            synchronized (deleteLock){
                deleteLock.notifyAll();
            }
        }

    }

    /**
     * 消费
     * @return
     */
    public Object poll(){
        Object o;
        //先获取对象锁，和生产者类似
        synchronized (deleteLock){
            //队列里没有数据则等待
            while (count.get() <= 0){
                try {
                    deleteLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //获取数据
            o = queue[count.get()];
            //递减
            int i = count.decrementAndGet();
            String name = Thread.currentThread().getName();
            System.out.println(name + "消费了一个，现有数量" + i);
        }
        //如果队列没有满，则可以唤醒生产者
        if (count.get() < size){
            //需要先获取到锁
            synchronized (addLock){
                addLock.notifyAll();
            }
        }
        return o;
    }

    /**
     * 简单的测试
     * @param args
     */
    public static void main(String[] args) {
        BlockQueue blockQueue = new BlockQueue();
        Thread t1 = new Thread(()-> {while (true){blockQueue.add(new Object());}});
        Thread t2 = new Thread(()-> {while (true){blockQueue.add(new Object());}});
        Thread t3 = new Thread(()-> {while (true){blockQueue.add(new Object());}});
        Thread t4 = new Thread(()-> {while (true){blockQueue.poll();}});
        Thread t5 = new Thread(()-> {while (true){blockQueue.poll();}});
        Thread t6 = new Thread(()-> {while (true){blockQueue.poll();}});
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
    }

}

效果：其实这个递增递减操作和打印操作也不是原子操作，

依次打印线程1,2,3

/**
 * @author lhd
 */
public class JoinTest {


    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> System.out.println(1));
        Thread t2 = new Thread(()-> System.out.println(2));
        Thread t3 = new Thread(()-> System.out.println(3));

        t1.start();
        t1.join();

        t2.start();
        t2.join();

        t3.start();
        t3.join();

    }

}