多线程间的通信

1、多线程中最常见的应用案例，生产者消费者问题

生产和消费同时执行，需要多线程。但是执行的任务不相同，处理的资源相同：线程的通信。

1、描述资源

2、描述生产者，因为具备着自己的任务。

3、描述消费者，因为具备着自己的任务。

问题1、运行第一次结果：数据错误，已经被生产很早期的商品，才被消费到。

出现线程安全问题，加入同步解决。使用的是同步函数。

问题已解决：不会再消费到之前很早期的商品。

问题2、发现了连续生产却没有消费，同时对同一个商品进行多次消费。

生产者生产了商品后应该告诉消费者来消费，这时的生产者应该处于等待状态。

消费者消费了商品后应该告诉生产者来生产，这时的消费者应该处于等待状态。

等待：wait();

告诉：notify();

package producer_consumer;

import java.util.function.Consumer;

//1、描述资源。属性：名称，编号。行为：对商品名称赋值，获取商品。
class Resource{
    private String name;
    private int count = 1;
    //定义标记
    private boolean flag = false;
    //提供设置的方法
    public synchronized void setName(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);
        //将标记改为true
        flag = true;
        //唤醒消费者
        this.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;
            //唤醒生产者
            this.notify();
    }
}
//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    Producer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
           r.setName("面包");
        }
    }
}
//3、描述消费者
class consumer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    consumer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
            r.out();
        }
    }
}

public class pctest {
    public static void main(String[] args) {
        //创建资源对象
        Resource r = new Resource();
        //创建线程任务
        Producer pro = new Producer(r);
        consumer con = new consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        t1.start();
        t2.start();
    }
}

2、等待唤醒机制

wait();

当前线程必须拥有次对象监视器（锁），到底改变的时哪个锁里面的线程？所以需要加锁，否则会抛出无效的监视器状态异常。会让线程处于等待状态，就是将线程临时存储到线程池中。

notify();

会唤醒线程池中任意一个等待的线程。

notifyAll();

会唤醒线程池中所有等待的线程。

记住：这些方法必须使用在同步中，因为必须要表示wait，notify等方法所属的锁。同一个锁上的notify，只能唤醒该锁上的被wait的线程。

为什么这些方法定义在object类中？

因为这些方法必须表示所需的锁，而锁可以时任意对象，任意对象可以调用的方法必然是object类中的方法。

3、多生产多消费问题

问题1：生产商品没有被消费，同一个商品被消费多次。

被唤醒的线程没有判断标记，造成了问题1的产生。

解决：只要让被唤醒的线程必须判断标记就可以了。将if判断标记的方式改为while。只要是多生产多消费，必须是while判断条件。

package producer_consumer;

import java.util.function.Consumer;

//1、描述资源。属性：名称，编号。行为：对商品名称赋值，获取商品。
class Resource{
    private String name;
    private int count = 1;
    //定义标记
    private boolean flag = false;
    //提供设置的方法
    public synchronized void setName(String name){
        while(flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name+count;
        count++;
        System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
        //将标记改为true
        flag = true;
        //唤醒消费者
        notify();
    }
    //在生产完之前不能去消费
    public synchronized void out(){
        while(!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            System.out.println(Thread.currentThread().getName()+"消费者"+this.name);
            flag = false;
            //唤醒生产者
            notify();
    }
}
//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    Producer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
           r.setName("面包");
        }
    }
}
//3、描述消费者
class consumer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    consumer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
            r.out();
        }
    }
}

public class pctest {
    public static void main(String[] args) {
        //创建资源对象
        Resource r = new Resource();
        //创建线程任务
        Producer pro = new Producer(r);
        consumer con = new consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(pro);
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

问题2：while判断后，四个线程全部等待，死锁。

原因：生产方唤醒了线程池中生产方的线程。没用。

解决方法：希望本方要唤醒对方。notify()唤醒任意一个，不可控，咋办？所以只能唤醒所有。使用notifyall。

jdk1.5之后提供了多生产多消费的解决方案。

在java.util.concurrent.locks 软件包中提供了响应的解决方案。

4、lock接口：比同步更屌

lock()：获取锁

unlock():释放锁

synchronized为隐式的锁操作。lock中提供了更多的显式的锁操作。可以替代同步。synchronized。

老锁替换新锁后，那么锁上的监视器方法wait、notify、notifyall也应该替换成新锁的监视器方法。

jdk新版中已经将原有的监视器方法封装到了一个Condition对象中。要获取监视器方法，首先需要获取Condition对象。

Condition对象的出现其实就是替代了Object中监视器的方法。

await();

signal();

signalAll();

package producer_consumer;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;

//1、描述资源。属性：名称，编号。行为：对商品名称赋值，获取商品。
class Resource{
    private String name;
    private int count = 1;
    //定义标记
    private boolean flag = false;
    //定义一个锁对象
    private Lock lock = new ReentrantLock();
    //获取锁上的Condition对象
    private Condition con = lock.newCondition();
    //提供设置的方法
    public void setName(String name){
        //获取锁
        lock.lock();
        try{
        while (flag){
            try {
                con.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name+count;
        count++;
        System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
        //将标记改为true
        flag = true;
        con.signalAll();
        }finally {
            lock.unlock(); //一定要执行
        }
    }
    //在生产完之前不能去消费
    public void out(){
        lock.lock();
        try {
            while (!flag) {
                try {
                    con.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "消费者" + this.name);
            flag = false;
            con.signalAll();
        }finally {
            lock.unlock();
        }
    }
}
//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    Producer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
           r.setName("面包");
        }
    }
}
//3、描述消费者
class consumer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    consumer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
            r.out();
        }
    }
}

public class pctest {
    public static void main(String[] args) {
        //创建资源对象
        Resource r = new Resource();
        //创建线程任务
        Producer pro = new Producer(r);
        consumer con = new consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(pro);
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

5、效率的提高

希望本方可以唤醒对方任意一个线程。

老程序中可以通过两个锁的嵌套完成，但是容易引发死锁。

新程序中可以解决这个问题，只用一个锁。

在一个锁上挂多个监视器对象Condition。

 

package producer_consumer;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;

//1、描述资源。属性：名称，编号。行为：对商品名称赋值，获取商品。
class Resource{
    private String name;
    private int count = 1;
    //定义标记
    private boolean flag = false;
    //定义一个锁对象
    private Lock lock = new ReentrantLock();
    //获取锁上的Condition对象
    private Condition con = lock.newCondition(); //负责生产
    private Condition pro = lock.newCondition(); //负责消费
    //提供设置的方法
    public void setName(String name){
        //获取锁
        lock.lock();
        try{
        while (flag){
            try {
                con.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name+count;
        count++;
        System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
        //将标记改为true
        flag = true;
        pro.signal();
        }finally {
            lock.unlock(); //一定要执行
        }
    }
    //在生产完之前不能去消费
    public void out(){
        lock.lock();
        try {
            while (!flag) {
                try {
                    pro.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "消费者" + this.name);
            flag = false;
            con.signal();
        }finally {
            lock.unlock();
        }
    }
}
//2、描述生产者
class Producer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    Producer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
           r.setName("面包");
        }
    }
}
//3、描述消费者
class consumer implements Runnable{
    private Resource r;
    //生产者一初始化就要有资源，需要将资源传递到构造函数中
    consumer(Resource r){
        this.r = r;
    }
    public void run(){
        while (true){
            r.out();
        }
    }
}

public class pctest {
    public static void main(String[] args) {
        //创建资源对象
        Resource r = new Resource();
        //创建线程任务
        Producer pro = new Producer(r);
        consumer con = new consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(pro);
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}