关于java多线程浅析一：简单实现生产消费模式

关于什么是线程，这里就不过多介绍了。但为什么要用多线程呢？原因无他，就是希望更好的利用CPU资源。当然，多线程在模拟很多实际场景下，也是一把利器，就比如生产-消费模式，使用不同的线程来充当生产者和消费者，就很容易实现一个简单的生产-消费模型。说到此，那我们就先利用线程中的wait()和notifyAll()方法来实现一个简单的生产-消费模式，之后再从最基本的线程的基本状态讲起。

多线程简单实现生产-消费模式

模型分析：顾名思义，生产-消费模式，必不可少需要两个角色：生产者（Producer）消费者（Customer），还有一个就是生产数据的厂房（Factory），具体生产消费分析过程如下：

1. 厂房有固定的生产商品的数量，也就是容量（capacity），其次还有就是目前商品的数量（quality ），quality<=capacity;
2. 生产者负责生产商品，但当quality=capacity时，就不再进行生产，而等待消费
3. 消费者负责消费商品，但当quality=0时，就不再进行消费，而等待生产

4. 当quality为零或者到达最大容量的时候，都应该告知生产者和消费者进行生产消费

   好，我们来看一下具体的代码实现：
   （1）Factory的实现：

//工厂
public class Factory{

    private int capacity;  //容量
    private int quality;      //实际数量

    public Factory(int capacity){
        this.capacity=capacity;
        this.quality= 0;
    }
    //生产
    public synchronized void produce(int val){
        try {
            while(val > 0){
                while(quality >= capacity){
                        wait();//当商品数量大于等于最大容量时，生产者不再生产，进行等待消费
                }
                int inc = (quality+ val) > capacity ? capacity-quality : val;
                quality+= inc;
                val -=inc;
                System.out.println("生产者"+Thread.currentThread().getName()+"生产了:"+inc+"个产品");
                notifyAll();//通知等待的消费线程进行消费
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //消费
    public synchronized void custome(int val){
        try {
            while(val > 0){
                while(quality <= 0){
                        wait();//当商品数量小于等于0时，消费者不再消费，进行等待生产
                }
                int dec = (val > quality ) ? quality : val;
                quality -= dec;
                val -= dec;
                System.out.println("消费者"+Thread.currentThread().getName()+"消费了:"+dec+"个产品");
                notifyAll();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

（2）Producer代码实现

//生产者
public class Producer{
    //注入一个工厂实例
    private Factory factory;

    public Producer(Factory factory){
        this.factory = factory;
    }
    //开启一个新的线程，传入待生产的数量，调用工厂的生产方法
    public void produce(int val){
        new Thread(){
            @Override
            public void run() {
                factory.produce(val);
            }
        }.start();
    }
}

（3）Customer代码实现

//消费者
public class Customer {
   //注入一个工厂实例
    private Factory factory;

    public Producer(Factory factory){
        this.factory = factory;
    }
    public void custome(int val){
        new Thread(){
            @Override
            public void run() {
                factory.custome(val);
            }
        }.start();
    }
}

（4）测试方法
public class Test {

public static void main(String[] args) {
    Factory factory = new Factory(200);//该对象只有一个,所以一下代码中只有一个同步锁
    Producer producer = new Producer(factory);
    Customer customer = new Customer(factory);

    producer.produce(80);
    customer.custome(90);
    producer.produce(140);
    customer.custome(180);
    producer.produce(110);

}

}
测试结果：

生产者Thread-0生产了:80个产品
消费者Thread-1消费了:80个产品
生产者Thread-2生产了:100个产品
消费者Thread-1消费了:10个产品
生产者Thread-4生产了:10个产品
消费者Thread-3消费了:100个产品
生产者Thread-4生产了:100个产品
消费者Thread-3消费了:80个产品
生产者Thread-2生产了:40个产品

这里主要用到了有关多线程知识中的wait（）方法和notifyAll（）方法，但我们知道，这两个方法是定义在Object类中，而并不是在Thread类中，具体原因将在后面的章节中进行说明。下一篇，我们讲一下线程的基本几个状态。