【基础】- 生产者消费者-等待唤醒机制 (经典Demo)

等待唤醒机制的应用场景很多，记录这个Demo，强化下。

抽象类

public abstract class Ticket implements Runnable {

    /**
     * 锁.
     */
    protected Object lock;

    /**
     * 共享资源：票.
     */
    protected static int ticket = 0;

    public Ticket(Object lock) {
        this.lock = lock;
    }
}

生产者

public class Producer extends Ticket {

    public Producer(Object lock) {
        super(lock);
    }

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (ticket < 10) {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("生产ticket，现有 " + ++ticket + " 张票");

                    lock.notifyAll();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

消费者

public class Consumer extends Ticket {

    public Consumer(Object lock) {
        super(lock);
    }

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (ticket > 0) {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("消费，剩余 " + --ticket + " 张票");

                    lock.notifyAll();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

启动生产者、消费者

public class Demo01 {

    public static void main(String[] args) {

        Object lock = new Object();

        Consumer consumer = new Consumer(lock);
        Producer producer = new Producer(lock);

        Thread consumer01 = new Thread(consumer);
        Thread consumer02 = new Thread(consumer);
        Thread consumer03 = new Thread(consumer);

        Thread producer01 = new Thread(producer);

        consumer01.start();
        consumer02.start();
        consumer03.start();
        producer01.start();
    }
}

执行结果：

生产ticket，现有 1 张票
生产ticket，现有 2 张票
生产ticket，现有 3 张票
生产ticket，现有 4 张票
生产ticket，现有 5 张票
生产ticket，现有 6 张票
生产ticket，现有 7 张票
生产ticket，现有 8 张票
消费，剩余 7 张票
消费，剩余 6 张票
消费，剩余 5 张票
消费，剩余 4 张票
消费，剩余 3 张票
消费，剩余 2 张票
消费，剩余 1 张票
消费，剩余 0 张票
生产ticket，现有 1 张票
生产ticket，现有 2 张票
····(循环)