典型的生产者消费者模式

下面是一个典型的生产者消费者模式写法，注释比较清晰，便于大家学习。

import HomeWork01.Container.Producer;

/**
 * 容器类，构建生产者和消费者两个内部类，和put()，take()两个方法；
 *@project Java_pro
 */
class Container {
    /**
     * size:容器容量；
     * array：构造的容器；
     * sth：放入容易的元素，每放入一次执行sth--；
     */
    private int size;
    private Object[] array;
    private volatile Integer sth = 100;

    /*构造方法传递容量参数*/
    public Container(int cap) {
        this.array = new Object[cap];
    }

    /**
     * tName：当前线程名称
     * @param obj:放入容器的对象
     * 判断容器容量是否已满，如果满了打印语句，执行wait()方法，阻塞调用此方法的线程，释放锁；
     * 否则在size位置放入obj，打印线程tName放入obj，并扩容；
     * 完成放入后广播通知其他正在处于wait()的线程，允许取数据；
     */
    public synchronized void put(Object obj) {
        String tName = Thread.currentThread().getName();

        while (size == array.length) {
            System.out.println("容器已经满了。");
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        array[size] = obj;
        System.out.println("Thread " + tName + " put: " + obj);
        size++;
        notifyAll();
    }

    /**
     * tName：当前线程名称
     * 判断容器容量是否已空，如果空了打印语句，执行wait()方法，阻塞调用此方法的线程，释放锁；
     * 否则取出首位元素，打印tName取出obj；
     * 取出后将1号至队尾所有元素赋值到0号位至队尾-1位，一共size-1个元素，size--;
     * 完成取出后广播通知其他正在处于wait()的线程，允许放数据；
     */
    public synchronized void take() {
        String tName = Thread.currentThread().getName();
        while (size == 0) {
            System.out.println("容器已经空了。");
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        Object temp = array[0];
        System.out.println("Thread " + tName + " take:" + temp);
        System.arraycopy(array, 1, array, 0, size - 1);
        size--;
        array[size] = null;

        notifyAll();
    }

    /*生产者线程调用put()方法放入数据sth*/
    class Producer extends Thread {
        Container container;

        public Producer(Container container) {
            this.container = container;
        }

        @Override
        public void run() {
            while (true) {
                container.put(sth);
                --sth;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
    }

    /*消费者线程调用take()方法取出数据sth*/
    class Consumer extends Thread {
        Container container;
        Object temp;

        public Consumer(Container container) {
            this.container = container;
        }

        @Override
        public void run() {
            while (true) {
                container.take();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }

        }
    }
}

public class Producer_ConsumerDemo {
    public static void main(String[] args) throws InterruptedException {
        Container c = new Container(5);

        Producer pro1 = c.new Producer(c);
        pro1.start();
        c.new Consumer(c).start();

    }

}