java知识点杂货铺【十】

目录

一、java生产者消费者问题

* 一、java生产者消费者问题*

　生产者消费者问题可谓是多线程的经典题目，相当于高中数学的母题一般了。
　生产者消费者问题实现的话一般设计这么几个类：
　１，仓库类，用来存储生产和消费的东西。
　２，生产者类，负责生产。
　３，消费者类，负责消费
　有时候还可以写一个生产消费种类的类，比如生产馒头、辣条之类的，这里就写一般的写法

/**
 * @ClassName: ProducerConsumerDemo
 * @Description: TODO(请用一句话描述这个类的作用)
 * @date 2016年11月20日 下午3:23:26
 * @author 张海平
 * 湖南师范大学工程与设计学院前栋407工作室
 * 
 */
package com.zhanghaiping.javaHomeWork;

import java.util.LinkedList;

class Storage{
    //仓库的最大存储量
    private int MAX_SIZE = 100;

    //存储载体
    private LinkedList<Object> list = new LinkedList<Object>();

    ///生产
    public void produce(int num) {

        //同步代码段
        synchronized (list) {
            while (list.size() + num > MAX_SIZE) {
                System.out.println("生产数量： " + num + "库存为： " + list.size()
                        + "  大于仓库容量，暂时不能生产");

                //释放锁，执行等待操作
                try {
                    list.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            //满足消费条件，开始生产
            for(int i =1;i <= num;i++){
                list.add(new Object());
            }
            System.out.println("已生产： " + num + "  现仓库容量为： " + list.size());
            //唤醒线程，开始消费
            list.notifyAll();
        }       
    }

    消费
    public void consumer(int num){
        synchronized (list) {

            //如仓库存储量不足，不能消费
            while (list.size() < num) {
                System.out.println("要消费的数量为： " + num + "  现库存容量为： " + list.size()
                        + " 暂时不能消费： ");
                // 释放消费线程锁，执行等待操作
                try {
                    list.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            //消费条件满足，开始消费
            for (int i = 0; i <= num; i++) {
                list.remove();
            }
            System.out.println("已消费：  " + num + "  现仓库容量为： " + list.size());

            //唤醒生产线程，开始生产
            list.notify();  
        }
    }
}

// 消费者类
class Consumer extends Thread{
    //每次消费数量
    private int num;

    //仓库
    private Storage storage;

    // 构造函数，建立仓库
    public Consumer(Storage storage){
        this.storage = storage;
    }

    //线程run方法
    @Override
    public void run() {
        consume(num);
    };

    //调用仓库的生产方法
    public void consume(int num) {
        storage.consumer(num);
    }

    public void setNum(int num) {
        this.num = num;
    }
}
//生产者类//
class Producer extends Thread{
     // 每次生产的产品数量  
    private int num;  

    // 所在放置的仓库  
    private Storage storage; 

    // 构造函数，设置仓库  
    public Producer(Storage storage)  
    {  
        this.storage = storage;  
    }  
    // 线程run函数  
    @Override
    public void run()  
    {  
        produce(num);  
    }  

    // 调用仓库Storage的生产函数  
    public void produce(int num)  
    {  
        storage.produce(num);  
    }  

    public void setNum(int num) {
        this.num = num;
    }
}

/主类
public class ProducerConsumerDemo extends Thread{

    public static void main(String[] args) {

        //仓库对象
        Storage storage = new Storage();

        //生产者对象
        Producer p1 = new Producer(storage);
        Producer p4 = new Producer(storage);
        Producer p2 = new Producer(storage);
        Producer p3 = new Producer(storage);
        Producer p5 = new Producer(storage);
        Producer p6 = new Producer(storage);
        Producer p7 = new Producer(storage);

        // 消费者对象
        Consumer c1 = new Consumer(storage);
        Consumer c2 = new Consumer(storage);
        Consumer c3 = new Consumer(storage);

        // 设置生产者产品生产数量  
        p1.setNum(10);  
        p2.setNum(10);  
        p3.setNum(10);  
        p4.setNum(10);  
        p5.setNum(10);  
        p6.setNum(10);  
        p7.setNum(80);

        // 设置消费者产品消费数量  
        c1.setNum(50);  
        c2.setNum(20);  
        c3.setNum(30);  

        // 线程开始执行  
        c1.start();  
        c2.start();  
        c3.start();

        p1.start();  
        p2.start();  
        p3.start();  
        p4.start();  
        p5.start();  
        p6.start();  
        p7.start(); 
    }
}

运行结果;

要消费的数量为： 50  现库存容量为： 0 暂时不能消费： 
要消费的数量为： 30  现库存容量为： 0 暂时不能消费： 
要消费的数量为： 20  现库存容量为： 0 暂时不能消费： 
已生产： 10  现仓库容量为： 10
要消费的数量为： 20  现库存容量为： 10 暂时不能消费： 
要消费的数量为： 30  现库存容量为： 10 暂时不能消费： 
要消费的数量为： 50  现库存容量为： 10 暂时不能消费： 
已生产： 10  现仓库容量为： 20
已生产： 10  现仓库容量为： 30
已生产： 10  现仓库容量为： 40
要消费的数量为： 50  现库存容量为： 40 暂时不能消费： 
已消费：  30  现仓库容量为： 9
要消费的数量为： 20  现库存容量为： 9 暂时不能消费： 
已生产： 10  现仓库容量为： 19
要消费的数量为： 20  现库存容量为： 19 暂时不能消费： 
要消费的数量为： 50  现库存容量为： 19 暂时不能消费： 
已生产： 80  现仓库容量为： 99
已消费：  50  现仓库容量为： 48
已消费：  20  现仓库容量为： 27
已生产： 10  现仓库容量为： 37

总结

生产者消费者问题做为一个多线程经典的问题，实现的方式还有很多种，这里就用了一种方法实现，一个题目要向足够理解透多线程，显然是不可能的，有精力的再用其他几种方法实现多线程，增加自己的理解。
有问题可以评论留言！！！