·多线程学习笔记（五）之多生产者多消费者中的线程问题

一时失言乱红尘 2022-06-16 02:26 123阅读 0赞

# 多生产多消费的问题 #

首先我们先看一个例子：

class ResourceDemo{
        
        private String name;
        private int count;
        private boolean flag = false;
        //生产者
        public synchronized void set(String name){
            if (flag){
                try{
                    this.wait();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.name = name + count;
            count++;
            System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
            flag = true;
            notify();
        }
        //消费者
        public synchronized void out(){
            if (!flag){
                try{
                    this.wait();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"......消费者......"+this.name);
            flag = false;
            notify();
        }
    }
    
    //生产者
    class Producer implements Runnable{
        
        private ResourceDemo r;
        Producer(ResourceDemo r){
            this.r = r;
        }
        public void run(){
            while (true){
                r.set("烤鸭");
            }
        }
    }
    //消费者
    class Consumer implements Runnable{
        
        private ResourceDemo r;
        Consumer(ResourceDemo r){
            this.r = r;
        }
        public void run(){
            while (true){
                r.out();
            }
        }
    }
    
    
    
    public class ProducerConsumerDemo {
        
        public static void main(String[] args){
            ResourceDemo r = new ResourceDemo();
            Producer pro = new Producer(r);
            Consumer con = new Consumer(r);
    
            //四个线程，两个负责生产，两个负责消费
            Thread t0 = new Thread(pro);
            Thread t1 = new Thread(pro);
            Thread t2 = new Thread(con);
            Thread t3 = new Thread(con);
    
            t0.start();
            t1.start();
            t2.start();
            t3.start();
        }
    }

可能出现如下结果：

![这里写图片描述][SouthEast]

为什么会出现如上现象？

假如t0线程在完成“烤鸭1”之后，此时第一次notify是没有作用的，因为目前没有等待的代码，因此执行完synchronized方法，释放锁，cpu此时可能执行t0或者其他线程，假设扔执行t0，由于flag判决，使之wait()等待，意味着t1,t2,t3处于**临时阻塞状态**，三个中的一个可能被cpu执行到，假设执行t1，由于flag判断，t1也wait(),接下来同理可能执行t2，在执行t2中的notify时，将随机唤醒同锁的一个等待线程，假设唤醒t0（注意：**唤醒并不代表有执行权，cpu切换执行权是随机的**），假设cpu扔执行t2，则t2也进入wait等待状态，释放执行权，假设t3执行，由于flag，也进入wait等待状态，因此**此时只有t0一个处于唤醒状态**，因此执行t0，**生产烤鸭2，count变为3**,**执行notify，此时问题便产生了**，**此时notify唤醒的是t2或者t3的话，进行消费，不会出现问题，若此时唤醒t1，将出现问题**，接下来假设扔执行t0，由于flag会进行等待

public synchronized void set(String name){
            if (flag){
                try{
                    this.wait();//t0等待，t1已唤醒，因此t1获取执行权后直接执行后面语句，即不许要再判断上面的if(flag)
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.name = name + count;
            count++;
            System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
            flag = true;
            notify();
        }

，此时**线程池中**只有t1是唤醒状态，其余线程都是等待状态，因此执行t1，**生产烤鸭3**，导致“烤鸭2”未被消费。**问题就是出现在了t1唤醒之后没有进行flag判断**，**如何想办法解决，使其“往回走，进行flag的判断再决定是否执行”**

# 解决数据错误问题 #

既然是想回头再进行flag的判断，实际上就是**if与while的区别**，if执行完判断后，进入执行语句，执行之后跳出if，而while则会不断的判断，直至不满足条件时才会跳出，因此将**if改成while**即可实现

//生产者
        public synchronized void set(String name){
            while (flag){
                try{
                    this.wait();//t0等待，t1已唤醒，因此t1获取执行权后直接执行后面语句，即不许要再判断上面的if(flag)
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.name = name + count;
            count++;
            System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
            flag = true;
            notify();
        }

但是又会出现如下的情况：

![这里写图片描述][SouthEast 1]

出现了死锁情况，**原因很简单：**当t1,t2,t3,都处于wait状态时，在执行t0，生产烤鸭2，flag设置为true，**执行notify，由于三个线程在等待，随机唤醒，唤醒t1**，假设cpu继续执行t0，由于flag，进行wait等待，此时线程只有t1处于唤醒状态，由于flag和while，不断在while循环中出不去，导致4个线程全部处于**等待状态**，导致了如上现象。

**总结while作用：完成每次线程被唤醒执行时都需要再次判断标记的目标，if判断标记只有一次，会导致不该运行的线程运行了，出现数据错误的情况**

# 解决“死锁”问题 #

造成如上死锁的原因是没有唤醒“对方”线程，因此要是通过notify能够唤醒指定线程便解决问题了，但是实际并没有这个方法。但是可以使用notifyAll，将等待线程全部唤醒，如果执行的是本方线程，由于while的flag判断会使之wait，执行的终将是“对方”线程，避免了死锁问题的发生，代码以一个为例（notify全部改为notifyAll即可）：

![这里写图片描述][SouthEast 2]

**notifyAll作用总结：保证本方线程一定会唤醒对方线程，notify只能唤醒一个线程，如果本方线程唤醒了本方线程，没有意义。**

通过如上两种改进，解决了**多生产多消费**的问题。

# notifyAll带来的效率问题 #

由于notifyAll唤醒全部等待线程，其中就可能有本方线程，并且获得执行权，会进行多次的flag标记判断，会带来效率上的问题。**在从jdk1.5开始，带来的新特性能够解决如上的需求**

# Lock接口 #

public interface Lock ，Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作，此实现允许更灵活的结构。同步synchronized，要么是同步代码块，要么是同步函数，仅仅是一种封装，而Lock直接把锁封装称为一种对象，可以直接对其进行操作。具体的有关Lock的相关内容在之后的学习笔记中进行学习整理。

[SouthEast]: /images/20220616/bdb436b68d99414997b5bb4dce383416.png
[SouthEast 1]: /images/20220616/9985b4e4083d47cbb1911fe7f035952f.png
[SouthEast 2]: /images/20220616/91b172c9280b4b0bac6bff787e46762d.png