线程间通信问题

最新推荐文章于 2022-11-10 17:32:00 发布
最新推荐文章于 2022-11-10 17:32:00 发布
阅读量194 收藏
点赞数
分类专栏： # JUC 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45417821/article/details/118725240
版权

文章目录

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

场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信

synchronized 方案

package com.sync;

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

    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        while (number != 0) { //判断是否是0 如果不是0 等待
            this.wait(); //在哪里睡，就在哪里醒
        }
        //如果number是0 就+1操作
        number++;
        System.out.println( Thread.currentThread().getName() + "::" + number );
        //通知其他线程
        this.notifyAll();
    }

    //-1的方法
    public synchronized void decr() throws InterruptedException {
        //判断
        while (number != 1) {
            this.wait();
        }
        //干活
        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 = 0; i <= 10; i++) {
                try {
                    share.incr();//+1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"AA").start();

        //创建线程
        new Thread( () -> {
            for (int i = 0; i <= 10; i++) {
                try {
                    share.decr();//-1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"BB").start();
    }
}

上述代码是只有两个线程，一个是+1操作，一个是 -1操作

在这里插入图片描述
控制台的效果如上，乍一看没什么问题，但是如果将两个线程变成四个线程，又该当如何呢

package com.sync;


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

    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        if(number != 0) { //判断是否是0 如果不是0 等待
            this.wait(); //在哪里睡，就在哪里醒
        }
        //如果number是0 就+1操作
        number++;
        System.out.println( Thread.currentThread().getName() + "::" + number );
        //通知其他线程
        this.notifyAll();
    }

    //-1的方法
    public synchronized void decr() throws InterruptedException {
        //判断
        if(number != 1) {
            this.wait();
        }
        //干活
        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 = 0; i <= 10; i++) {
                try {
                    share.incr();//+1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"AA").start();

        //创建线程
        new Thread( () -> {
            for (int i = 0; i <= 10; i++) {
                try {
                    share.decr();//-1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"BB").start();

        //创建线程
        new Thread( () -> {
            for (int i = 0; i <= 10; i++) {
                try {
                    share.decr();//-1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"CC").start();

        //创建线程
        new Thread( () -> {
            for (int i = 0; i <= 10; i++) {
                try {
                    share.decr();//-1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"DD").start();
    }
}

在这里插入图片描述
控制台效果如上图，发现有复数，与开始的需求并不一样，这就是所谓的虚假唤醒问题

在wait端，我们必须把判断布尔条件和wait()放到while循环中，而不能用if语句，原因是可能会引起虚假唤醒。
那么，究竟什么是虚假唤醒，导致虚假唤醒的原因又是什么呢？

什么是虚假唤醒？

举个例子，我们现在有一个生产者-消费者队列和三个线程。

1） 1号线程从队列中获取了一个元素，此时队列变为空。

2） 2号线程也想从队列中获取一个元素，但此时队列为空，2号线程便只能进入阻塞(cond.wait())，等待队列非空。

3） 这时，3号线程将一个元素入队，并调用cond.notify()唤醒条件变量。

4） 处于等待状态的2号线程接收到3号线程的唤醒信号，便准备解除阻塞状态，执行接下来的任务(获取队列中的元素)。

5） 然而可能出现这样的情况：当2号线程准备获得队列的锁，去获取队列中的元素时，此时1号线程刚好执行完之前的元素操作，返回再去请求队列中的元素，1号线程便获得队列的锁，检查到队列非空，就获取到了3号线程刚刚入队的元素，然后释放队列锁。

6） 等到2号线程获得队列锁，判断发现队列仍为空，1号线程“偷走了”这个元素，所以对于2号线程而言，这次唤醒就是“虚假”的，它需要再次等待队列非空。

使用while()判断的原因

如果用if判断，多个等待线程在满足if条件时都会被唤醒(虚假的)，但实际上条件并不满足，生产者生产出来的消费品已经被第一个线程消费了。
这就是我们使用while去做判断而不是使用if的原因：因为等待在条件变量上的线程被唤醒有可能不是因为条件满足而是由于虚假唤醒。所以，我们需要对条件变量的状态进行不断检查直到其满足条件，不仅要在 wait() 方法 前检查条件是否成立，在 wait() 之后也要检查。

纠正后的代码

package com.sync;


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

    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        while (number != 0) { //判断是否是0 如果不是0 等待
            this.wait(); //在哪里睡，就在哪里醒
        }
        //如果number是0 就+1操作
        number++;
        System.out.println( Thread.currentThread().getName() + "::" + number );
        //通知其他线程
        this.notifyAll();
    }

    //-1的方法
    public synchronized void decr() throws InterruptedException {
        //判断
        while (number != 1) {
            this.wait();
        }
        //干活
        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 = 0; i <= 10; i++) {
                try {
                    share.incr();//+1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"AA").start();

        //创建线程
        new Thread( () -> {
            for (int i = 0; i <= 10; i++) {
                try {
                    share.decr();//-1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"BB").start();

        //创建线程
        new Thread( () -> {
            for (int i = 0; i <= 10; i++) {
                try {
                    share.decr();//-1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"CC").start();

        //创建线程
        new Thread( () -> {
            for (int i = 0; i <= 10; i++) {
                try {
                    share.decr();//-1
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        } ,"DD").start();
    }
}

在这里插入图片描述
控制台结果如上图，此时虚假问题已经解决

Lock方案

package com.lock;

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 Lock 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 ThreadDemo2 {

    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();

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

在这里插入图片描述
控制台如上图：

虚假唤醒

正常操作：
假设AA(+1),BB(-1),CC(+1),DD(-1)
开始AA获得了 +1
如果CC抢到了这个线程，就是等待，
如果AA再抢到了这个线程，还是等待
如果BB抢到了，则 -1 操作

非正常操作：

开始AA获得了 +1
如果CC抢到了这个线程，就是等待，
结果AA又抢到了+1，执行如下结果
此时CC被唤醒了，上一个CC是在等待，则此时CC已经醒来了
而if判断只判断一次，解决办法是给if判断变成while判断，
当在线程中醒来时，while将继续判断

Alienware^
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
写两个线程，一个加，一个减
qq_30629571的博客
04-26 1593
写两个线程，一个加，一个减 package helloworld; import java.util.*; /** * 加一线程与减一线程共同操作一个数 两个问题： 1、线程同步--synchronized 2、线程之间如何共享同一个j变量--内部类 * * @author liuwei */ public class Test { int j = 0; public sync
线程及 进程间的通信问题！
jtop0的专栏
04-08 3440
一个很好的编程随想的博客http://program-think.blogspot.com/2009/03/producer-consumer-pattern-0-overview.html 架构设计：生产者/消费者模式[0]：概述  1、如何确定数据单元 2、队列缓冲区 3、环形缓冲区 4、双缓冲区 生产 消费 2010-06-01 10:13 #in
4.线程通信问题（重点）
weixin_48554146的博客
03-28 174
java多线程文章目录 目录 生产者消费者问题 问题解决 实现代码 原理 Condition 三种方法 生产者消费者问题 生产者消费者问题，也称有限缓冲问题，是一个线程同步问题的经典案例。 在缓冲区（仓库）为空时，消费者不能进行消费 在缓冲区（仓库）为满时，生产者不能进行生产 在一个线程进行生产或者消费时，其他线程不能进行消费或者生产操作，即保持线程间的同步 问题解决 因为需要保持线程间的同步，即一个线程消费（或生产）完，其它线程才能争抢CP...
线程间通信的问题
captainconnie的博客
10-13 379
一、解决线程间通信的问题：异步消息处理机制： 第一种情况：匿名内部类实现接口，直接在主线程中复写run()方法； 1、在主线程方法外创建Handler类的对象，利用匿名类的形式，并复写其handleMessage()方法； 2、在主线程中开启新的线程，在新的线程里，利用Message对象，携带处理后的信息，用handler对象调用其sendMessage()方法，将Message对象发送出去
线程间通信问题的解决
易水寒
01-06 923
线程间通信问题的解决： -- wait：告诉当前线程放弃监视器并进入睡眠状态，直到其它线程进入一同监视器并且调用notify为止。 --notify：唤醒同一对象监视器中调用wait的第一个线程，这类似排队买票，一个人买完后，后面的人才可以买。 --notifyAll:唤醒同一对象监视器中调用wait的所有线程，具有最高级别的线程首先被唤醒并执行。 package xiancheng;
Java多线程 线程通信问题
qq_46370017的博客
04-02 315
Linux下多线程间通信
09-14
在Linux环境下，多线程间通信是实现并发执行任务并协调数据访问的关键技术。线程间的通信主要通过共享内存和同步机制来实现，因为线程天然具有共享数据结构的能力，这意味着全局变量可以在多个线程之间共享。然而，...
Python如何实现线程间通信
01-19
问题 你的程序中有多个线程，你需要在这些线程之间安全地交换信息或数据 解决方案 从一个线程向另一个线程发送数据最安全的方式可能就是使用 queue 库中的队列了。创建一个被多个线程共享的 Queue 对象，这些线程...
Java线程间通信不同步问题原理与模拟实例
08-25
本文将深入探讨线程间通信不同步问题的原理，并通过一个模拟实例进行分析。 线程间通信不同步问题通常出现在以下几个场景： 1. **生产者-消费者问题**：当生产者线程还在生产数据时，消费者线程就开始尝试消费，...
JUC学习（三）：synchronized和Lock实现线程间通信（包含虚假唤醒的讲解）
m0_49499183的博客
03-20 427
线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析 ： 场景---两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信 一、synchronized实现 /** * 实现线程A对一个值+1，线程B对该值-1 */ //第一步：创建资源类，定义属性和操作方法 class Share{ //目标值 int number = 0; //+...
两个线程循环对一个变量进行加一和减一
qq_34787830的博客
06-03 1972
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class KT { int num = 0; Lock lock = new ReentrantLock(); ...
创建四个线程，两个线程对i加1，两个线程对i减1
sinat_32856935的博客
08-10 4259
  package com.dairui.chars; public class ThreadTest { public static void main(String[] args) { ThreadDemo1 threadDemo1 = new ThreadDemo1(); ThreadDemo1.A a = threadDemo1.new A(); ThreadDe...
写四个线程，二个加1，二个对一个变量减一
淡漠黑白
09-10 2581
昨天的面试题（天元网络）  两个问题：    1、线程同步--synchronized    2、线程之间如何共享同一个j变量--内部类  [java] view plaincopy package test;      /**   * 加一线程与减一线程共同操作一个数   * 两个问题：     * 1、线程同步--synchron
java多线程实现数据_java多线程实现两个线程对数据加1，两个线程对数据减1
weixin_42153801的博客
02-25 999
代码如下：两个加的线程实现数据共享不能同时操作数据两个减的线程实现数据共享不能同时操作数据加线程和减线程能同时操作package com.tan.test313.homework.thread;/*** 试编写程序实现 4个线程， 其中两个线程每次对j增加1， 另外两个线程对j每次减少1。** @use* @author tanyouhao* @date 2013-3-13 下午7:28:36* ...
线程通信的四种方式
热门推荐
weixin_43786099的博客
11-10 2万+
多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式： 通过 volatile 关键字 通过 Object类的 wait/notify 方法 通过 condition 的 await/signal 方法 通过 join 的方式 现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。 通过 volatile 关键字 通过
多线程-线程间通信
weixin_51604685的博客
07-12 2337
关于多线程中线程通信相关的知识
线程之间的通信
V_Axis的博客
02-28 2197
通过几个面试题来了解线程之间的通信。 问题清单： 如何让两个线程依次执行？ 如何让两个线程按照指定方式有序交叉运行？ 四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 A B C 是同步运行的。 三个线程各自准备，等到三个线程都准备好后，再一起执行某个任务。 子线程完成某件任务后，把得到的结果回传给主线程。 两个线程依次执行？ 假设有两个线程，一个是线程...
java 线程间通信
最新发布
06-16
Java 中的线程间通信（Thread Communication）是为了让多个线程之间能够协作、同步和共享数据。这是实现并发编程的关键，有助于提高程序的效率和响应性。Java 提供了几种机制来支持线程间通信： 1. **wait() 和 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值