Java学习笔记之--------线程（五）多线程之生产者消费者模式

生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者不会在缓冲区空时消耗数据。

要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常使用的方法有信号灯法，管程等。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。

我们首先了解一下以下的方法：
notify()：唤醒在此对象监视器上等待的单个线程
notifyAll()：唤醒在此对象监视器上等待的所有线程
wait()：在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前线程等待。注意：wait()和sleep()不相同，wait会释放资源，释放锁。

信号灯法的示例如下，Player作为生产者，Watcher作为消费者，他们拥有相同的资源Movie。

public class Player implements Runnable {
    private Movie m;
    public Player(Movie m) {
        super();
        this.m = m;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (0 == i % 2) {
                m.play("左");
            } else {
                m.play("右");
            }
        }
    }
}

public class Watcher implements Runnable {
    private Movie m;
    public Watcher(Movie m) {
        super();
        this.m = m;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            m.watch();
        }
    }
}

public class Movie {
    private String pic;
    // 信号灯
    // flag -->T，表示生产者生产，消费者等待，生产完成后通知消费
    // flag -->F，表示消费者消费，生产者等待，消费完成后通知生产
    private boolean flag = true;
    // 播放
    public synchronized void play(String pic) {
        // 生产者等待
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 开始生产
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("生产了：" + pic);
        // 生产完毕
        this.pic = pic;
        // 通知消费
        this.notify();
        // 生产者停下
        this.flag = false;
    }
    public synchronized void watch() {
        // 消费者等待
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 开始消费
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费了" + pic);
        // 消费完毕
        // 通知生产
        this.notifyAll();
        // 停止消费
        this.flag = true;
    }
}

public class App {
    public static void main(String[] args) {
        // 共同的资源
        Movie m = new Movie();
        // 多线程
        Player p = new Player(m);
        Watcher w = new Watcher(m);
        
        new Thread(p).start();
        new Thread(w).start();
    }
}

执行结果如下：

只有生产了才可以消费，不会出现连续生产两个相同的。