【JUC并发编程03】线程间通信

文章目录

3 线程间通信
- 3.1 synchronized 实现案例
- 3.2 虚假唤醒问题
- 3.3 Lock 实现案例

3 线程间通信

线程间通信有两种实现方法：

关键字 synchronized 与 wait()/notify() 这两个方法一起使用可以实现等待/通知模式

Lock 接口中的 newContition() 方法返回 Condition 对象，Condition 类也可以实现等待/通知模式

用 notify()通知时，JVM 会随机唤醒某个等待的线程

使用 Condition 类可以进行选择性通知， Condition 比较常用的两个方法：
  1.  await() 会使当前线程等待,同时会释放锁,当其他线程调用 signal()时,线程会重新获得锁并继续执行2.  signal() 用于唤醒一个等待的线程

操作线程的时候，等待线程使用wait()
通知另外的线程操作用notify()、notifyAll()
假设有两个线程，该线程在执行过程中，判断值（不是该值等待，让其他线程抢），操作值，通知另外一个线程的调度

3.1 synchronized 实现案例

实现两个线程对 num 这个值操作，一个线程加1，一个线程减1，交替实现多次

// 创建一个资源类
class Share{// 设置临界资源private int number = 0;// 实现+1操作public synchronized void incr() throws InterruptedException {// 操作：判断、干活、通知if (number != 0) {// number不为0，等待// wait 有一个特点，在哪里睡，就在哪里醒this.wait();    }number++;System.out.print(Thread.currentThread().getName()+"::"+number);// 唤醒其他线程// 注意这里的通知是随机的，就是只能通知全部this.notifyAll();}// 实现-1操作public synchronized void decr() throws InterruptedException {// 操作：判断、干活、通知if (number != 1) {// number不为0，等待this.wait();}number--;System.out.println(Thread.currentThread().getName()+"::"+number);this.notifyAll();}
}
public class InterThreadCommunication {public static void main(String[] args) {Share share = new Share();new Thread(new Runnable() {@Overridepublic void run() {try {for (int i = 0; i < 100; i++) {share.incr();}} catch (InterruptedException e) {e.printStackTrace();}}},"A").start();new Thread(new Runnable() {@Overridepublic void run() {try {for (int i = 0; i < 100; i++) {share.decr();}} catch (InterruptedException e) {e.printStackTrace();}}},"B").start();}
}

输出结果如下

3.2 虚假唤醒问题

虚假唤醒主要出现在多线程中出现。

同样使用上述案例，现在有四个线程，分别为A，B，C，D，其中A，C线程做+1操作，B，D线程做-1操作，想要的结尾应该是A，C线程输出值为1，B，D线程输出值为0 。修改上述代码如下：

// 创建一个资源类
class Share{// 设置临界资源private int number = 0;// 实现+1操作public synchronized void incr() throws InterruptedException {// 操作：判断、干活、通知if (number != 0) {// number不为0，等待this.wait();}number++;System.out.print(Thread.currentThread().getName()+"::"+number+"--->");// 唤醒其他线程this.notifyAll();}// 实现-1操作public synchronized void decr() throws InterruptedException {// 操作：判断、干活、通知if (number != 1) {// number不为0，等待this.wait();}number--;System.out.println(Thread.currentThread().getName()+"::"+number);this.notifyAll();}
}
public class InterThreadCommunication {public static void main(String[] args) {Share share = new Share();new Thread(new Runnable() {@Overridepublic void run() {try {for (int i = 0; i < 100; i++) {share.incr();}} catch (InterruptedException e) {e.printStackTrace();}}},"A").start();new Thread(new Runnable() {@Overridepublic void run() {try {for (int i = 0; i < 100; i++) {share.decr();}} catch (InterruptedException e) {e.printStackTrace();}}},"B").start();new Thread(new Runnable() {@Overridepublic void run() {try {for (int i = 0; i < 100; i++) {share.incr();}} catch (InterruptedException e) {e.printStackTrace();}}},"C").start();new Thread(new Runnable() {@Overridepublic void run() {try {for (int i = 0; i < 100; i++) {share.decr();}} catch (InterruptedException e) {e.printStackTrace();}}},"D").start();}
}

输出结尾如下，显然最后输出的结果和我们预想的是不一样的。那么问题出在哪里呢？

查找 JDK1.8 文档，在 Object 的 wait() 方法中有如下介绍

在一个参数版本中，中断和虚假唤醒是可能的，并且该方法应该始终在循环中使用

也就是说，这种现象叫做【虚假唤醒】。所谓虚假唤醒，就是 wait()方法的一个特点，总结来说 wait() 方法使线程在哪里睡就在哪里醒。 这是什么意思呢？那就以上述代码为例。

当 A 进入临界区，BCD三个线程在 if 判断后进入 wait() 等待，当A线程完成操作，此时 number 值为1，notifyAll() 会随机唤醒一个线程。

现在C被唤醒，由于 wait() 方法使线程在哪里睡就在哪里醒，所以接下来C在执行时不会再通过 if 判断而是直接+1，此时 number 就是2了。从而导致最后输出的结果和我们预想的不一致。

按照 JDK1.8 文档的提示，将资源类的 incr() 方法和 decr() 方法中的if语句改为循环语句，修改代码如下：

// 创建一个资源类
class Share{// 设置临界资源private int number = 0;// 实现+1操作public synchronized void incr() throws InterruptedException {// 操作：判断、干活、通知while (number != 0) {// number不为0，等待// 哪里睡哪里起this.wait();}number++;System.out.print(Thread.currentThread().getName()+"::"+number+"--->");// 唤醒其他线程this.notifyAll();}// 实现-1操作public synchronized void decr() throws InterruptedException {// 操作：判断、干活、通知while (number != 1) {// number不为0，等待this.wait();}number--;System.out.println(Thread.currentThread().getName()+"::"+number);this.notifyAll();}
}

此时输出结果符合我们预期：

3.3 Lock 实现案例

在 Lock 接口中，有一个 newCondition() 方法，该方法返回一个新 Condition 绑定到该实例 Lock 实例。

Condition 类中有 await() 和 signalAll() 等方法，和 synchronized 实现案例中的 wait() 和 notifyAll() 方法相同。所以通过 Lock 接口创建一个 Condition 对象，由该对象的方法进行等待和唤醒操作

实例代码如下，主要改动的是资源类，main方法中代码不变。

class Share {// 设置临界资源private int number = 0;// 创建一个Comprivate Lock lock = new ReentrantLock();private Condition condition = lock.newCondition();// 实现+1操作public void incr() {// 上锁lock.lock();try {// 判断while (number != 0) {condition.await();}// 干活number++;System.out.print(Thread.currentThread().getName() + "::" + number + "--->");// 通知condition.signalAll();} catch (InterruptedException e) {e.printStackTrace();} 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();} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}}
}

测试结尾如下：