Java多线程实现生产者消费者延伸问题

在操作系统中有一类问题被称为生产者消费者问题：意为，有数个生产者生产产品，有数个消费者消费产品，他们共享一定数量的缓存。

这里用java多线程编程，实现生产者消费者问题的一种延伸，橘子苹果问题。

题目如下：

有苹果橘子生产者各20个，有苹果橘子消费者各20个，他们公用20个缓存区。要求能随时查看缓存区内容，随时查看生产消费内容情况，随时暂停生产开始生产。

我们的实现思路：

1.首先创建一个缓存区类，其中包含静态的，长度大小为20的数组，用来存放和取出生产的产品；一个静态的日志变量List，用来记录对缓存区的操作；

以及对缓存区的操作方法和对日志变量的操作方法。

2.创建苹果生产者类和橘子生产者类，他们继承Thread类，其中包含四个变量：缓存类的实例对象，生产者自己的id，运行周期，暂停信号量；以及对run方法的重写。

3.创建苹果消费者类和橘子消费者类，他们继承Thread类，其中包含四个变量：缓存类的实例对象，生产者自己的id，运行周期，暂停信号量；以及对run方法的重写。

4.在程序中添加静态代码块，初始时创建20个橘子生产者20个苹果生产者，20个橘子消费者，20个苹果消费者。

5.在程序开始时开启线程。

6.表现层我们可以利用jsp来实现，用ajax做刷新模仿实时更新（这里用jsp实现并不是最好的选择）

一下贴出实现代码：

缓存类

public class BufferCase {
    private static List<String> buffer = new ArrayList<String>();
    private static List<String> log = new ArrayList<String>();
    //制造缓存内容
    public synchronized boolean inBuffer(String goods){
        if(buffer.size()==20)
            return false;
        else if(buffer.add(goods))
            return true;
        else
            return false;
    }
    //消费缓存内容
    public synchronized String outBuffer(int type){
        for(int i=0;i<buffer.size();i++){
            if(type==1){
                if(buffer.get(i).equals("apple")){
                    buffer.remove(i);
                    return new String("apple");
                }
            }
            if(type==2){
                if(buffer.get(i).equals("orange")){
                    buffer.remove(i);
                    return new String("orange");
                }
            }
        }
        return null;
    }
    //写入日志内容
    public synchronized void inLog(String log){
        this.log.add(log);
    } 
    //清除日志内容
    public static synchronized void clearLog(){
        log.clear();
    }
    //输出日志内容
    public static List<String> outLog(){
        return log;
    }
    //输出缓存内容
    public static List<String> outBuffer(){
        return buffer;
    }
}

消费者类

public class OrangeConsumer extends Thread {
    BufferCase buffer = null;
    int time= 2000 ;//运行周期
    boolean flag=true;//是否暂停
    int id;//消费者id
    public void setFlag(boolean flag){
        this.flag = flag;
    }
    public void setTime(int time) {
        this.time = time;
    }
    public OrangeConsumer(BufferCase bf,int id){
        buffer = bf;
        this.id = id;
    }
    
    @Override
    public void run() {
        while(true){
        // 设定运行周期
        try {
            sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //消费橘子
        synchronized(buffer){
            if(flag==false)
                try {
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            String goods = null;
            goods = buffer.outBuffer(2);
            if(goods==null)
                buffer.inLog("橘子消费者"+id+"消费橘子失败");
            else
                buffer.inLog("橘子消费者"+id+"消费橘子成功");
        }
        super.run();
        }
    }
    
}

public class AppleConsumer extends Thread{
    public BufferCase buffer = null;
    int time = 2000;//运行周期
    boolean flag=true;//是否暂停
    int id;//消费者id
    public void setFlag(boolean flag){
        this.flag = flag;
    }
    public void setTime(int time) {
        this.time = time;
    }
    public int getTime(){
        return this.time;
    }
    public AppleConsumer(BufferCase bf,int id){
        buffer = bf;
        this.id = id;
    }
    
    @Override
    public void run() {
        while(true){
            // 设定运行周期
            try {
                sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //消费苹果
            
                synchronized(buffer){
                    if(flag==false)
                        try {
                            wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    String goods = null;
                    goods = buffer.outBuffer(1);
                    if(goods==null)
                        buffer.inLog("苹果消费者"+id+"消费苹果失败");
                    else
                        buffer.inLog("苹果消费者"+id+"消费苹果成功");
                }
            super.run();
        }
    }
}

生产者类

public class AppleProducer extends Thread {
    BufferCase buffer = null;
    int time= 2000 ;//运行周期
    boolean flag=true;//是否暂停
    int id;//消费者id
    public void setFlag(boolean flag){
        this.flag = flag;
    }
    public void setTime(int time) {
        this.time = time;
    }
    public AppleProducer(BufferCase bf,int id){
        buffer = bf;
        this.id = id;
    }
    
    @Override
    public void run() {
        while(true){
        // 设定运行周期
        try {
            sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //生产苹果
        if(flag==true)
        synchronized(buffer){    
            String goods = new String("apple");
            if(buffer.inBuffer(goods))
                buffer.inLog("苹果生产者"+id+"放入苹果成功");
            else
                buffer.inLog("苹果生产者"+id+"放入苹果失败");
        }
        super.run();
        }
    }    
}

public class OrangeProducer extends Thread{
    BufferCase buffer = null;
    int time= 2000 ;//运行周期
    boolean flag=true;//是否暂停
    int id;//消费者id
    public void setFlag(boolean flag){
        this.flag = flag;
    }
    public void setTime(int time) {
        this.time = time;
    }
    public OrangeProducer(BufferCase bf,int id){
        buffer = bf;
        this.id = id;
    }
    
    @Override
    public void run() {
        while(true){
        // 设定运行周期
        try {
            sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //生产橘子
        if(flag==true)
        synchronized(buffer){
            String goods = new String("orange");
            if(buffer.inBuffer(goods))
                buffer.inLog("橘子生产者"+id+"放入橘子成功");
            else
                buffer.inLog("橘子生产者"+id+"放入橘子失败");
        }
        super.run();
        }
    }
}

初始化角色类：

public class AllRoles {
    public static AppleConsumer[] ac = new AppleConsumer[20];
    public static OrangeConsumer[] oc = new OrangeConsumer[20];
    
    public static AppleProducer[] ap = new AppleProducer[20];
    public static OrangeProducer[] op = new OrangeProducer[20];
    
    static{
        BufferCase bf = new BufferCase();
        for(int i=0;i<20;i++){//初始化生产者消费者线程
            ap[i] = new AppleProducer(bf,i);
            op[i] = new OrangeProducer(bf,i);
            
            ac[i] = new AppleConsumer(bf,i);
            oc[i] = new OrangeConsumer(bf,i);
        }
    }
}

各种业务逻辑

//开启线程
for(int i=0;i<20;i++){
                AllRoles.ac[i].start();
                AllRoles.ap[i].start();
                AllRoles.oc[i].start();
                AllRoles.op[i].start();
            }
//暂停线程
for(int i=0;i<20;i++){
            AllRoles.ac[i].setFlag(false);
            AllRoles.ap[i].setFlag(false);
            AllRoles.oc[i].setFlag(false);
            AllRoles.op[i].setFlag(false);
        }
//重启线程
for(int i=0;i<20;i++){
            AllRoles.ac[i].setFlag(true);
            AllRoles.ap[i].setFlag(true);
            AllRoles.oc[i].setFlag(true);
            AllRoles.op[i].setFlag(true);
        }

运行结果图：