Java多线程实现生产者消费者模式

用java实现生产者消费者模式，在全部代码之后会对重点、难点一一讲解！
以下是全部代码：

class Demo7 {
    public static void main(String[] args) {
        //资源对象
        Resource r = new Resource();
        //生产者
        Producer pro = new Producer(r);
        //消费者
        Consumer con = new Consumer(r);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;// false 表示存储的货物为空，ture 则反之。

    public synchronized void set(String name) // 生产产品
    {
        while (flag)
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }

        this.name = name + "---" + count++;//例如：Thread-0....生产者....+商品+---1

        System.out.println(Thread.currentThread().getName() + "....生产者...."
                + this.name);
        flag = true;
        this.notifyAll();
    }

    public synchronized void out()// 消费产品
    {
        while (!flag)
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }

        System.out.println(Thread.currentThread().getName()
                + "........消费者........." + this.name);
        flag = false;
        this.notifyAll();

    }
}

/**
 * 
 * 生产者类
 * 
 */
class Producer implements Runnable {
    private Resource res; // 组合 定义了一个资源类变量

    Producer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.set("+商品+");
        }

    }
}

/**
 * 
 * 消费者类
 * 
 */
class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.out();
        }

    }
}

运行结果（因为是无限循环的生产消费，所以提供部分截图）：

Thread-0....生产者....+商品+---1
Thread-3........消费者.........+商品+---1
Thread-1....生产者....+商品+---2
Thread-2........消费者.........+商品+---2
Thread-0....生产者....+商品+---3
Thread-3........消费者.........+商品+---3
Thread-1....生产者....+商品+---4
Thread-2........消费者.........+商品+---4
Thread-0....生产者....+商品+---5
Thread-3........消费者.........+商品+---5
Thread-1....生产者....+商品+---6
Thread-2........消费者.........+商品+---6
Thread-0....生产者....+商品+---7
Thread-3........消费者.........+商品+---7
Thread-1....生产者....+商品+---8
Thread-2........消费者.........+商品+---8
.....................................

以下为详细讲解部分（请不要复制下面的代码）：
1.
先看main方法

public static void main(String[] args) {
        //资源对象
        Resource r = new Resource();2.
        //生产者
        Producer pro = new Producer(r);3.
        //消费者
        Consumer con = new Consumer(r);4.

        Thread t1 = new Thread(pro);生产
        Thread t2 = new Thread(pro);生产
        Thread t3 = new Thread(con);消费
        Thread t4 = new Thread(con);消费

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        这里创建了四个线程。1、2为生产者；34为消费者
    }

接下来，按照程序执行顺序讲解：
2.

class Producer implements Runnable {
    private Resource res; // 组合 定义了一个资源类变量
    获得“资源对象”
    Producer(Resource res) {
        this.res = res;
    }都懂

    public void run() {
        while (true) {注意，这里是无限循环
            res.set("+商品+");
        }
    }
}

/**
 * 
 * 消费者类
 * 
 */
class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {注意，这里是无限循环
            res.out();
        }

    }
}

下面是超级重点了，以为本篇文章存在的价值所在

class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;// false 表示存储的货物为空，ture 则反之。

    public synchronized void set(String name) // 生产产品
    {
        while (flag)
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }

        this.name = name + "---" + count++;//例如：Thread-0....生产者....+商品+---1

        System.out.println(Thread.currentThread().getName() + "....生产者...."
                + this.name);
        flag = true;
        this.notifyAll();
    }

    public synchronized void out()// 消费产品
    {
        while (!flag)
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }

        System.out.println(Thread.currentThread().getName()
                + "........消费者........." + this.name);
        flag = false;
        this.notifyAll();

    }
}

假设先执行out()，当前为flag为false，进入out()后先上锁（遇到了synchronized），可是while判断后，进入wait()，（这个wait方法会释放CPU资源同时解锁，当该线程被唤醒的时候，会从上锁的位置开始），假设现在运气很差，又一次被消费者抢到了，那么剩下的那个消费着即使进入了out可是因为当前的flag也会被wait()，所以，一开始只有当一个生产者进入后，才能不被wait()，同时上锁，不允许第二个生产者“生产”，执行完set()后，flag变为true，然后通过notifyAll来唤醒之前被wait的两个消费者线程(这是说的比较坏的情况)，由于当前flag为false所以，同理当前能够不被wait的也只有消费者，这两个线程来抢夺然后上锁，就这样四个线程反反复复的抢夺，两两为一组，如此循环下去，就会看到生产了马上就要消费，因为最多可以存储一个货物（简单理解为：true、false）。