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

多生产多消费的问题

首先我们先看一个例子：

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();
    }
}

可能出现如下结果：

为什么会出现如上现象？

假如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();
    }

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

出现了死锁情况，原因很简单：当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即可）：

    //生产者
    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;
        notifyAll();
    }

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

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

notifyAll带来的效率问题

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

Lock接口

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