（新思路）生产者消费者模型（condition的解决方法）

来源：互联网发布：c罗皇马知乎编辑：程序博客网时间：2024/06/07 08:03

需求：

一个固定容量的同步容器，拥有put和get方法，还有getCount方法

能够支持两个生产者和10个消费者线程的阻塞调用

使用wait和notify/notifyAll实现

方法一：wait和notify的方法

思考：

1.第8行和第21行为什么用while不用if？

生产者1和生产者2判断满了---》wait---》消费者消费了一个---》生产者1继续执行，add了一个对象又满了----》生产者2从while继续执行（再次判断是否满），再决定是否add。（如果用if，生产者2唤醒后不判断是否满了，直接add，list会溢出）

2.第17行和第31行为什么用notifyAll不用notify？

如果用notify，生产者满了--》wait----》只唤醒一个线程，不小心唤醒了生产者，继续wait---》没有其它线程被唤醒---》死锁

如果用notifyAll，生产者满了--》wait---》唤醒所有线程，如果唤醒的还是生产者，继续wait--》消费者线程拿到锁执行

public class MyContainer<T>{
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10;//容量为10
    private int count = 0;
    
    //生产者调用
    public synchronized void put(T t){
        while(lists.size() == MAX){//不断判断容器是否满，满了则等待
            try{
                this.wait();
            }catch(InterruptException e){
                e.printStackTrace();
            }
        }
        lists.add(t);
        ++count;
        this.notifyAll();//通知消费者线程进行消费
    }
    //消费者调用
    public synchronized T get(){
        while(lists.size() == 0){//不断判断容器是否为空，空了则等待
            try{
                this.wait();
            }catch(InterruptException e){
                e.printStackTrace();
            }
        }
        T tmp = lists.removeFirst();
        --count;
        this.notifyAll();//通知生产者线程进行生产
        return tmp;
    }
    
    //主线程
    public static void main(String[] args){
        MyContainer<String> container = new MyContainer<>();
        //启动10个消费者线程
        for(int i=0;i<10;i++){
            new Thread(()->{
                for(int j=0;j<5;j++){
                    System.out.println(c.get());//每个线程从容器中取5个对象
                }
            }, "消费" + i).start();
        }
        
        try{
            TimeUtils.SECONDS.sleep(2);
        }catch(InterruptException e){
            e.printStackTrace();
        }
        
        //启动2个生产者
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<25;j++) c.put(Thread.currentThread().getName() + " " + j);
            }, "生产" + i).start();
        }
    }
}

方法二：lock和condition方法

可以精确控制唤醒生产者还是消费者线程

public class MyContainer<T>{
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10;//容量为10
    private int count = 0;
    
    private Lock lock = new ReentrainLock();
    private Condition producer = lock.newCondition();//生产者条件
    private Condition consumer = lock.newCondition();//消费者条件
    
    //生产者调用
    public void put(T t){
        try{
            lock.lock();//上锁
            while(lists.size() == MAX){//不断判断容器是否满，满了则等待
                producer.await();
            }
            
            lists.add(t);
            ++count;
            consumer.signalAll();//通知消费者线程进行消费
        }catch(InterruptException e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
        
    }
    //消费者调用
    public T get(){
        
            try{
                lock.lock();//上锁
                while(lists.size() == 0){//不断判断容器是否为空，空了则等待
                    consumer.await();
                }
                T tmp = lists.removeFirst();
                --count;
                producer.signalAll();//通知生产者线程进行生产
                
            }catch(InterruptException e){
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        
        
        return tmp;
    }
    
    //主线程
    public static void main(String[] args){
        MyContainer<String> container = new MyContainer<>();
        //启动10个消费者线程
        for(int i=0;i<10;i++){
            new Thread(()->{
                for(int j=0;j<5;j++){
                    System.out.println(c.get());//每个线程从容器中取5个对象
                }
            }, "消费" + i).start();
        }
        
        try{
            TimeUtils.SECONDS.sleep(2);
        }catch(InterruptException e){
            e.printStackTrace();
        }
        
        //启动2个生产者
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<25;j++) c.put(Thread.currentThread().getName() + " " + j);
            }, "生产" + i).start();
        }
    }
}

阅读全文

1 0