线程间通信

3，线程间通信

线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析

多线程编程模板:1.判断 2.干活 3.通知

线程通信的两种写法

• synchronized()中使用wait()和notifyAll()
• lock()中使用Condition()的await()和signalAll()

两种方法的区别（为什么要用lock()替换synchronized()）：lock()的Condition()能够精准通知，精准唤醒

场景-----两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求

用线程间通信

3.1使用synchronized锁创建线程进行加一减一操作

package com;

class Share{
    //初始化
    private int number=0;
    //+1方法
    public synchronized void incr(){
        //第二部，判断，0 +1
        while(number!=0){
            try {
                this.wait();//等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果number为0，+1
        number++;
        System.out.println(Thread.currentThread().getName()+"：："+number);
        //通知其他线程,重启其他线程
        this.notifyAll();
    }
    //创建-1方法
    public synchronized void decr(){
        //第二部，判断，0 +1
        while(number!=1){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果number为1，-1
        number--;
        System.out.println(Thread.currentThread().getName()+"：："+number);
        //通知其他线程,重启其他线程
        this.notifyAll();
    }
}
public class ThreadDemo1  {
    public static void main(String[] args) {
        Share share = new Share();

        new Thread(()->{
            for (int i=1;i<=10;i++){
                try {
                    share.incr();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i=1;i<=10;i++){
                try {
                    share.decr();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();
    }

}

结果：

​```
BB：：0
AA：：1
BB：：0
AA：：1
BB：：0
AA：：1
BB：：0
AA：：1
BB：：0
​```

3.2 使用ReentrantLock锁创建线程进行加一减一

package com;

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

//第一步 创建资源类，定义属性和操作方法
class Share {
    private int number = 0;

    //创建Lock
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1
    public void incr() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (number != 0) {
                condition.await();//等待
            }
            //干活
            number++;
            System.out.println(Thread.currentThread().getName()+" :: "+number);
            //通知
            condition.signalAll();//唤醒其他线程
        }finally {
            //解锁
            lock.unlock();
        }
    }

    //-1
    public void decr() throws InterruptedException {
        lock.lock();
        try {
            while(number != 1) {
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+" :: "+number);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo1 {

    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

    }

}

注意：
当前线程调用await的时候必须先获取到锁，而执行了await方法之后当前线程回释放该锁并且进入waiting状态，直到其他线程调用该对象的nodify方法或者notifyAll方法。

我们知道Condition中的signal方法和Object类里面的notify方法效果类似，并且调用方法之前需要先获取到锁，Condition中的await方法和Object类里面的wait方法效果类似，也是调用之前需要获取到锁，而调用之后会释放锁。

//使用if做条件判断时可能发生虚假唤醒问题
if(number!=1){
            try {
                this.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

走到await方法，当前线程挂起，释放掉锁，这时候number变量由于没有被锁住，所以可能会有其他线程将number值修改，导致条件判断产生变化。当另一个线程调用signal唤醒此线程的时候，if和while的区别就体现出来了，如果是if的话线程被唤醒就会直接从await方法往下执行，但是这时候number可能被修改，number!=1条件可能又满足了，这种情况应该是让线程继续挂起，但是用if会唤醒线程，产生了所谓的虚假唤醒，而如果用while的话，线程被唤醒之后还会在执行一次条件判断，确保条件number!=1不满足的时候才唤醒线程。

4,线程间定制化通信

4.1 案例介绍

==问题: A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照

此顺序循环 10 轮==

//第一步 创建资源类，定义属性和操作方法
class Share {
    private int number = 0;
    //声明锁
    private ReentrantLock lock = new ReentrantLock();
    //声明钥匙 A
    private Condition conditionA = lock.newCondition();
    //声明钥匙 B
    private Condition conditionB = lock.newCondition();
    //声明钥匙 C
    private Condition conditionC = lock.newCondition();

    /**
     * A 打印 3 次
     */
    public void printA(int j) {
        try {
            lock.lock();
            while (number != 0) {
                conditionA.await();
            }
            System.out.println(Thread.currentThread().getName() + "输出 A,第" + j + "轮开始");
            //输出 3 次 A
            for (int i = 0; i < 3; i++) {
                System.out.println("A");
            }
            //开始打印 B
            number = 1;
            //唤醒 B
            conditionB.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * B 打印 4 次
     */
    public void printB(int j) {
        try {
            lock.lock();
            while (number != 1) {
                conditionB.await();
            }
            System.out.println(Thread.currentThread().getName() + "输出 B,第" + j + "轮开始");
            //输出 4 次 B
            for (int i = 0; i < 4; i++) {
                System.out.println("B");
            }
            //开始打印 C
            number = 2;
            //唤醒 C
            conditionC.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * C 打印 5 次
     */
    public void printC(int j) {
        try {
            lock.lock();
            while (number != 2) {
                conditionC.await();
            }
            System.out.println(Thread.currentThread().getName() + "输出 C,第" + j + " 轮开始");
            //输出 5 次 C
            for (int i = 0; i < 5; i++) {
                System.out.println("C");
            }
            //开始打印 A
            number = 0;
            //唤醒 A
            conditionA.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo1 {

    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for (int i = 1; i <= 3; i++) {

                share.printA(i);

            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 1; i <= 3; i++) {

                share.printB(i);

            }
        }, "BB").start();

        new Thread(() -> {
            for (int i = 1; i <= 3; i++) {

                share.printC(i);

            }
        }, "CC").start();

    }

}