线程之间通信方式讲解

在Java中提供了wait/notify这个机制，用来实现条件等待和唤醒。这个机制我们平时工作中用的少，但是在很多底层源码中有用到。
比如以抢占锁为例，假设线程A持有锁，线程B再去抢占锁时，它需要等待持有锁的线程释放之后才能抢占，那线程B怎么知道线程A什么时候释放呢？这个时候就可以采用通信机制

我们以一个生产者-消费者示例来演示：

生产者代码：

public class Product implements Runnable{
    private Queue<String> msg;
    private int maxSize;

    public Product(Queue<String> msg, int maxSize) {
        this.msg = msg;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        int i=0;
        while(true){
            i++;
            synchronized (msg){ //同一把锁.
                if(msg.size()==maxSize){
                    //如果队列满了
                    try {
                        System.out.println("生产者阻塞");
                        msg.wait(); //阻塞当前线程
                        System.out.println("生产者阻塞后，重新获得锁，执行...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if(msg.size() == 0){
                    
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("生产者生产消息:"+i);
                msg.add("生产消息："+i);
                System.out.println("生产者释放锁");
                msg.notify(); //唤醒处于阻塞状态下的线程
            }
        }
    }
}

消费者代码

public class Consumer implements Runnable{
    private Queue<String> msg;
    private int maxSize;

    public Consumer(Queue<String> msg, int maxSize) {
        this.msg = msg;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while(true){
            synchronized (msg){
                while(msg.isEmpty()){
                    //如果消息队列为空了
                    try {
                        System.out.println("消费者阻塞");
                        msg.wait(); //阻塞当前线程
                        System.out.println("消费者阻塞后，重新获得锁，执行...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者消费消息："+msg.remove());
                System.out.println("消费者释放锁");
                msg.notify(); //唤醒处于阻塞状态下的生产者
//                msg.notifyAll();//唤醒处于阻塞状态下所有的线程
            }
        }
    }
}

测试代码：

public class TestMain {

    public static void main(String[] args) {
        Queue<String> queue=new LinkedList<>();
        int maxSize=5;
        Product product=new Product(queue,maxSize);
        Consumer consumer=new Consumer(queue,maxSize);
        Thread t1=new Thread(product);
        Thread t2=new Thread(consumer);
        t1.start();
        t2.start();
    }
}

测试结果：

生产者生产消息:1
生产者释放锁
消费者消费消息：生产消息：1
消费者释放锁
消费者阻塞
生产者生产消息:2
生产者释放锁
生产者生产消息:3
生产者释放锁
消费者阻塞后，重新获得锁，执行...
消费者消费消息：生产消息：2
消费者释放锁
消费者消费消息：生产消息：3
消费者释放锁
消费者阻塞
生产者生产消息:4
生产者释放锁
生产者生产消息:5
生产者释放锁
生产者生产消息:6
生产者释放锁
生产者生产消息:7
生产者释放锁
生产者生产消息:8
生产者释放锁
生产者阻塞
消费者阻塞后，重新获得锁，执行...
消费者消费消息：生产消息：4
消费者释放锁
消费者消费消息：生产消息：5
消费者释放锁
消费者消费消息：生产消息：6
消费者释放锁
消费者消费消息：生产消息：7
消费者释放锁
消费者消费消息：生产消息：8
消费者释放锁
消费者阻塞
生产者阻塞后，重新获得锁，执行...
生产者生产消息:9
生产者释放锁
消费者阻塞后，重新获得锁，执行...
消费者消费消息：生产消息：9
消费者释放锁
消费者阻塞

我们可以看到这么一个规律：
1.生产者释放锁——生产者阻塞——消费者获得锁，执行
2.消费释放锁——消费者阻塞——生产者获得锁，执行
是这样一个周而复始的规律

注意：
1.等待应该总是在循环中发生，如下代码写
synchronized (obj) {
* while (condition does not hold)
* obj.wait();
* … // Perform action appropriate to condition
* }
2.wait()和notify必须是持有同一个对象的监视器，否则会抛出异常@IllegalMonitorStateException

3.wait可以设置过期时间
4.notifyAll()方法是释放所有等待该锁的线程，然后竞争到锁的线程会执行
5.wait(),notify(),notifyAll()方法是Object对象的方法
原因一：Java中，任何对象都可以作为锁，既然wait是放弃对象锁，当然就要把wait定义在这个对象所属的类中更通用一些，由于所有类都继承于Object，我们完全可以把wait方法定义在Object类中，这样，当我们定义一个新类，并需要以它的一个对象作为锁时，不需要我们再重新定义wait方法的实现，而是直接调用父类的wait(也就是Object的wait)。
原因二：有的人会说，既然是线程放弃对象锁，那也可以把wait定义在Thread类里面啊，新定义的线程继承于Thread类，也不需要重新定义wait方法的实现。然而，这样做有一个非常大的问题，一个线程完全可以持有很多锁，你一个线程放弃锁的时候，到底要放弃哪个锁？

6.可以类比Condition中的await()和signal(),signalAll()方法，两者效果相似

本文是综合自己的认识和参考各类资料（书本及网上资料）编写，若有侵权请联系作者，所有内容仅代表个人认知观点，如有错误，欢迎校正； 邮箱：1354518382@qq.com 博客地址：https://blog.csdn.net/qq_35576976/