利用Synchronized、wait和notify简单实现生产者消费者模型

什么是生产者消费者模型

生产者和消费者之间通过一个容器解决耦合，两者之间不直接通讯，每当消费者消费，都直接从容器中取，相当于找了个代理一样，每当生产者生产完不用等待消费者消费，消费者消费完也不用等待生产者生产，直接挂起即可。解决了消费与生产直接的不平衡，高效利用了资源。

有哪些应用？

比如java中的线程池、生产者把任务丢给线程池，线程池创建线程并处理任务，如果将要运行的任务数大于线程池的基本线程数就把任务扔到阻塞队列里，这种做法比只使用一个阻塞队列来实现生产者和消费者模式显然要高明很多，因为消费者能够处理直接就处理掉了，这样速度更快，而生产者先存，消费者再取这种方式显然慢一些。
还有连接池：数据库中的连接池，网络连接池，因为数据库连接是非常耗时的，网络中建立连接也是，连接池原理跟线程池差不多，不多介绍。

编码实战

生产者与消费者模型的实现有很多种，我这里以synchronized、wait、notify来实现，这种方式比较简单。用syschronized实现同步，wait来释放资源等待，notify唤醒线程。
编写一个容器类，来做池子，里面可以进行生产资源、消费资源。关于线程同步的知识自行了解。
然后编写两个线程类，作为生产者，消费者，生产者调用池子里的生产方法，消费者调用池子里的消费方法。至于什么时候该生产补充，什么时候该消费，也由池子通过wait、notify控制。

package p2;

//使用wait与notify实现
public class ProducerConsumer {

    public static void main(String[] arg) {

        Resource resource = new Resource();
        // 生产者线程
        ProducerThread p1 = new ProducerThread(resource);
        ProducerThread p2 = new ProducerThread(resource);
        ProducerThread p3 = new ProducerThread(resource);
        // 消费者线程。测试时可以少开几个消费线程看看具体
        ConsumerThread c1 = new ConsumerThread(resource);
        ConsumerThread c2 = new ConsumerThread(resource);
        ConsumerThread c3 = new ConsumerThread(resource);

        p1.start();
        p2.start();
        p3.start();
        c1.start();
        c2.start();
        c3.start();

    }

}

// 编写资源类
class Resource {
//当前资源池数量
    private int currentSize = 0;
    //允许数量
    private int allowSize = 10;

    // 取走资源，如果当前资源大于0则可以移除（消费），移除之后唤醒生产线程。否则进入等待释放线程资源
    public synchronized void remove() {
        if (currentSize > 0) {
            currentSize--;
            System.out.println(Thread.currentThread().getName() + "消费一件资源，当前资源池有" + currentSize + "个");

            notifyAll();
        } else {

            // 没有资源 消费者进入等待状态
            try {
                System.out.println(Thread.currentThread().getName() + "当前资源过少，等待增加");
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

    public synchronized void add() {
        // 如果当前数量小于限制数量则可以增加，增加后唤醒消费者消费,否则等待消费，释放锁
        if (currentSize < allowSize) {
            currentSize++;
            System.out.println(Thread.currentThread().getName() + "生产一件资源，当前资源池有" + currentSize + "个");
            notifyAll();

        } else {

            try {
                System.out.println(Thread.currentThread().getName() + "当前资源过多，等待消费");
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

}
//消费线程
class ConsumerThread extends Thread {
    private Resource resource;

    ConsumerThread(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            //避免生产消费太快测试的时候看不到打印，休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //移除代表消费
            resource.remove();
        }

    }

}
//生产者线程
class ProducerThread extends Thread {
    private Resource resource;

    ProducerThread(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //生产
            resource.add();
        }

    }

}