高并发与多线程网络学习笔记(五)：线程的通信

数据同步与共享
多个线程在抢占CPU的时候会出现切换，对共享变量的修改无法保证先后顺序。因此如果存在对共享变量的判断，则需要对其判断和修改进行同步改写。

synchronized同步

使用synchronized所在的代码，相当于加上一层栅栏，就像我们去动物园检票口一样，一开始大家从各个地方来，然后排队一个个地检票，检完票后又分散各个地方玩。

同步方法

锁为this，即当前实例。

 public synchronized void save(){}

锁为当前class

 public synchronized static void save(){}

同步代码块

锁为object，设置的常变量，保证锁的相同性，避免修改

  synchronized(object){
    }

线程通信等待与唤醒

要点

• wait() 与 notify/notifyAll 方法必须在同步代码块中使用
• wait() 与 notify/notifyAll()的object是当前同步锁
• 判断条件要用while而不是if，因为wait线程被唤醒之后会继续执行接下来的代码，并不会重新检查判断条件，因此需要用while循环检查。

wait过程

• 当线程执行wait()时，会释放所有当前对象有关的同步锁，然后让出CPU，进入waitSet，线程状态变为blocked
• 当被唤醒之后，线程会重新进入runnable，如果抢到锁之后会从wait()语句之后继续执行(唤醒的顺序由JDK版本决定，不是FIFO)

notify过程

• 当执行notify/notifyAll方法时，会唤醒一个该对象锁waitSet的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。
• notify是随机唤醒waitSet中的某个线程，不能保证是唤醒哪一个，有可能导致假死状态(多个生产者和消费者，生产者唤醒的还是生产者)；notifyall是唤醒waitSet所有线程

Sleep与wait区别

• sleep是Thread方法，wait是Object方法
• sleep不会释放锁，wait会释放当前监视器对象
• sleep不依赖锁，wait会依赖必须在同步方法内持有监视器对象
• sleep不需要唤醒，wait需要唤醒（带时间参数的wait方法除外）

wait/notify线程通信例子：

public class ProduceConsumerVersion1 {
    private int i=0;
    private final  Object LOCK=new Object();
    private volatile boolean isProduce=false;
    private void  produce(){
        synchronized (LOCK){
            if(isProduce){
                try {
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                i++;
                System.out.println("p->"+i);
                LOCK.notify();
                isProduce=true;
            }
        }
    }
    private  void consume(){
        synchronized (LOCK){
            if(isProduce){
                System.out.println("C->"+i);
                LOCK.notify();
                isProduce=false;
            }else{
                try {
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {

        ProduceConsumerVersion1 pc=new ProduceConsumerVersion1();
        new Thread("P"){
            @Override
            public void run() {
                while(true)
                   pc.produce();
            }
        }.start();
        new Thread("C"){
            @Override
            public void run() {
              while(true)
                pc.consume();
            }
        }.start();
    }
}

对于等待的线程会被放入等待队列中。

注意以上版本在多个生产者和消费者情景下会导致程序假死（虽然没有死锁，但是线程都无法往下执行），造成这种情况的原因是：
假设有两个消费者c1\c2和两个生产者P1/P2,当程序运行时会存在如下状态：P1/P2/c1都处于wait状态，当c2消费完成后调用notify()方法唤醒的是c1,这时由于生产者生产的数据已经被消费过了，所以c1调用了wait(),此时所有线程都进入等待状态，造成程序的假死。notify()函数任意唤醒一个线程。

解决方法：使用while和notifyAll()方法（是所有block住的线程进入就绪状态）进行改造

public class ProduceConsumerVersion3 {
    private int i=0;
    private final  Object LOCK=new Object();

    private volatile boolean isProduce=false;

    private void  produce(){
        synchronized (LOCK){
            while(isProduce) {
                try {
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
                i++;
                System.out.println("p->"+i);
                LOCK.notifyAll();
                isProduce=true;
        }
    }
    private  void consume(){
        synchronized (LOCK){
            while(!isProduce){
                try {
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("C->"+i);
            LOCK.notifyAll();
            isProduce=false;

        }

    }

    public static void main(String[] args) {

        ProduceConsumerVersion3 pc=new ProduceConsumerVersion3();
        new Thread("P"){
            @Override
            public void run() {
                while(true)
                   pc.produce();
            }
        }.start();
        new Thread("C"){
            @Override
            public void run() {
              while(true)
                pc.consume();
            }
        }.start();
    }

}