JUC高并发编程3：线程间通信

最新推荐文章于 2024-10-18 13:25:14 发布
最新推荐文章于 2024-10-18 13:25:14 发布
阅读量1k 收藏 26
点赞数 9
分类专栏： # JUC Java 文章标签： 笔记 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosw0521/article/details/142579001
版权
Java 同时被 2 个专栏收录
65 篇文章 1 订阅
订阅专栏
JUC
14 篇文章 0 订阅
订阅专栏

1 线程间通信

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

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

1.1 synchronized方法

// 第一步 创建资源类，定义属性和操作方法
class Share{

    //初始值
    private int number = 0;

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

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

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

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

    }
}

1.2 Lock方案

// 第一步 创建资源类，定义属性和操作方法
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 = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"CC").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"DD").start();
    }
}

1.3 虚假唤醒问题

在Java中，线程间通信通常使用 Object 类的 wait()、notify() 和 notifyAll() 方法来实现。这些方法与条件变量类似，但同样可能会出现虚假唤醒（Spurious Wakeup）的问题。

1.3.1 什么是虚假唤醒？

虚假唤醒是指一个线程在没有被显式通知的情况下被唤醒。换句话说，即使没有调用 notify() 或 notifyAll() 方法，等待的线程也可能被唤醒。这种现象在某些操作系统或线程库中是允许的，因为它可以简化某些实现。

1.3.2 为什么会出现虚假唤醒？

虚假唤醒的原因可能包括：

  1. 操作系统调度：操作系统可能在某些情况下唤醒线程，即使没有显式的通知。
  2. 多核处理器：在多核处理器上，线程可能在不同的核心上运行，导致某些同步机制不完全可靠。
  3. Java 实现：Java 的线程库实现可能会允许虚假唤醒，以提高性能或简化实现。

1.3.3 如何处理虚假唤醒？

为了避免虚假唤醒带来的问题，通常的做法是在循环中检查条件变量。这样，即使线程被虚假唤醒，它也会在循环中重新检查条件，如果条件不满足，线程会继续等待。

以下是一个使用 wait() 和 notifyAll() 的典型示例：

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

public class SpuriousWakeupExample {
    private static final Lock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();
    private static boolean ready = false;

    public static void main(String[] args) throws InterruptedException {
        Thread workerThread = new Thread(new Worker());
        workerThread.start();

        // 主线程设置条件并通知
        Thread.sleep(1000); // 模拟一些工作
        lock.lock();
        try {
            ready = true;
            condition.signalAll(); // 通知等待的线程
        } finally {
            lock.unlock();
        }

        workerThread.join();
    }

    static class Worker implements Runnable {
        @Override
        public void run() {
            lock.lock();
            try {
                // 在循环中检查条件
                while (!ready) {
                    condition.await(); // 等待条件满足
                }
                // 条件满足，执行工作
                System.out.println("Worker thread is processing data");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                lock.unlock();
            }
        }
    }
}

1.3.4 关键点

  1. 循环检查条件：在 await() 方法周围使用 while 循环来检查条件，而不是 if 语句。这样可以确保即使线程被虚假唤醒，它也会重新检查条件。
  2. 使用 Lock 和 Condition：在示例中使用了 ReentrantLock 和 Condition，这是 Java 中更灵活的同步机制。你也可以使用 synchronized 关键字和 Object 的 wait()、notify() 和 notifyAll() 方法，但原理是相同的。
  3. 处理中断：在 await() 方法中捕获 InterruptedException，并处理线程中断的情况。

通过这种方式，可以有效避免虚假唤醒带来的问题，确保线程在条件真正满足时才继续执行。

1.4 多线程编程步骤

  • 第一步创建资源类，在资源类创建属性和操作方法

  • 第二步在资源类操作方法

    • 判断
    • 干活
    • 通知

  • 第三步创建多个线程，调用资源类的操作方法

  • 第四步防止虚假唤醒问题

2 线程间定制化通信

让线程按照指定顺序进行通信。

2.1 案例介绍

启动三个线程，按照如下要求执行：
AA线程打印 5 次 A，BB 线程打印 10 次 B，CC 线程打印 15 次 C,按照此顺序循环 10 轮

2.2 流程分析

在这里插入图片描述

2.3 代码实现

// 第一步 创建资源类，定义属性和操作方法
class ShareResourse{
    // 定义标识位
    private int flag = 1; // 1:AA; 2:BB; 3:CC
    //创建Lock
    private Lock lock = new ReentrantLock();

    //创建三个condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    //打印5次，参数第几轮
    public void print5(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try{
            while (flag != 1){
                //等待
                c1.await();
            }
            //干活
            for (int i = 0; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i +"， 轮数："+ loop);
            }
            //通知
            flag = 2; //修改标识位2
            c2.signal();//通知BB线程
        }finally {
            // 释放锁
            lock.unlock();
        }
    }

    //打印10次，参数第几轮
    public void print10(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try{
            while (flag != 2){
                //等待
                c2.await();
            }
            //干活
            for (int i = 0; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i +"， 轮数："+ loop);
            }
            //通知
            flag = 3; //修改标识位3
            c3.signal();//通知CC线程
        }finally {
            // 释放锁
            lock.unlock();
        }
    }


    //打印15次，参数第几轮
    public void print15(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try{
            while (flag != 3){
                //等待
                c3.await();
            }
            //干活
            for (int i = 0; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i +"， 轮数："+ loop);
            }
            //通知
            flag = 1; //修改标识位1
            c1.signal();//通知AA线程
        }finally {
            // 释放锁
            lock.unlock();
        }
    }
}
public class ThreadDemo3 {
    // 第三步创建多个线程，调用资源类的操作方法
    public static void main(String[] args) {
        ShareResourse shareResourse = new ShareResourse();
        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    shareResourse.print5(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    shareResourse.print10(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    shareResourse.print15(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"CC").start();
    }
}

synchronized实现同步的基础：Java中的每一个对象都可以作为锁。具体表现为以下3种形式。
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的class对象。
对于同步方法块，锁是synchonized括号里配置的对象

3 思维导图

在这里插入图片描述

4 参考链接

【【尚硅谷】大厂必备技术之JUC并发编程】

·云扬·
关注
专栏目录
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
Java 高并发编程详解：多线程与架构设计
GitChat
12-10 6914
内容简介 本书主要包含四个部分： 部分主要阐述 Thread 的基础知识，详细介绍线程的 API 使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。 第二部分引入了 ClassLoader，这是因为 ClassLoader 与线程不无关系，我们可以通过 synchronized 关键字，或者 Lock 等显式锁的方式在代码的编写阶段对共享资源进行数据一致...
JUC高并发编程1：JUC概述
云扬的博客
09-23 1134
本文是尚硅谷JUC高并发编程的学习笔记。包括JUC简介、进程与线程、线程的状态 、wait与sleep的区别、并发和并行、管程、用户线程和守护线程等。供个人学习使用。
JUC高并发编程(03) -- 线程间通信
姜皓的博客
05-08 273
线程间通信
Java——JUC高并发编程，面试必问（ 线程间通信 ）
xiangqian0721的博客
10-20 136
3.线程间通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 面试题 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信。 3.1 synchronized 方案 /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 */ public static void main(String[] args){
高级技术之 JUC 高并发编程
qq_40823822的博客
03-13 323
JUC
JUC高并发编程
丹辰子的博客
08-01 422
1.JUC概述 1.1什么是juc 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 线程和进程概念 1.进程和线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实
《Java高并发编程详解：多线程与架构设计》笔记（一）
四问四不知的博客
04-13 434
序言 有时候自己看过的书第一次看可能没有完全理解，过段时间再去看，你会发现有不一样的收获，毕竟我只是一个普普通通的人，不是什么特别厉害一看就明白的人。 线程 1、使用Jconsole或Jstack命令来查看JVM线程。Jconsole是JDK自带的可视化界面，如下图， Jstack命令查看对应PID（使用命令ps -ef查看进程）,如下图我写了一个死锁的demo，使用jstack 进程号可以看到情况。 线程NEW状态：当用关键字new创建一个Thread对象时，线程为New状态。 .
《尚硅谷高级技术之JUC高并发编程》学习笔记03—— 线程间通信
weixin_43301424的博客
11-26 504
文章目录synchronized 方案Lock 方案线程间定制化通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析。 synchronized 方案 /** * synchronized 关键字实现线程交替加减 */ public class TestSynchronized { /** * 交替加减 * @param args */ public static void main(S
java高级技术JUC高并发编程教程2021(1.5G)
04-11
java高级技术JUC高并发编程教程2021(1.5G) 〖课程介绍〗: java高级技术JUC高并发编程教程2021(1.5G) 〖课程目录〗:   01-JUC高并发编程-课程...10-JUC高并发编程-线程间通信-虚假唤醒问题.mp4 N+ }* P' s3 r&
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
这个模式可以很好地解决多线程间的数据同步和通信问题。 在课程的后续部分，介绍了8锁的现象。这是指在多线程环境下，对同一个对象的不同同步方法进行调用时，线程之间可能发生的竞争条件。了解8锁的现象可以帮助...
Go Wails 学习笔记：创建第一个项目
程序媛平平无奇的一天
10-14 1194
Wails 通过结合前端技术和 Go 后端，提供了一个高效的方式来开发跨平台的桌面应用。其简单的项目初始化和清晰的结构使得开发者能够快速上手。通过 Wails，可以充分利用 Web 开发技能，同时获得原生桌面应用的优势。
贪心算法笔记
qq_45190745的博客
10-15 313
贪心算法笔记
《vue leaflet学习实践笔记》
yk_ddm的博客
10-16 241
目录vue leaflet学习实践笔记 vue leaflet学习实践笔记
深入理解计算机系统阅读笔记-第十章
最新发布
马不停提的专栏
10-18 562
虚拟存储器是硬件异常、硬件地址翻译、主存、磁盘文件和内核软件的完美交互，它为每个进程提供了一个大的、一致的、私有地址空间。通过一个很清晰的机制，虚拟存储器 提供了三个重要能力：1、它将主存看成是一个存储在磁盘上的地址空间的高速缓存，在主存中只保存活动区域，并根据需要在磁盘和主存之间来回传递数据，通过这种方式，它高效地使用了主存；2、它为每个进程提供了一致的地址空间，从而简化了存储器管理；3、它保护了每个进程的地址空间不被其他进程破坏。
学习笔记——交换——STP（生成树）基本概念
灵韵的博客
10-16 1124
端口收到一个BPDU报文后，抽取该BPDU报文中累计根路径开销字段的值，加上该端口本身的路径开销即为累计根路径开销。从一个非根桥到达根桥的路径可能有多条，每一条路径都有一个总的开销值，此开销值是该路径上所有接收BPDU端口的端口开销总和(即BPDU的入方向端口)。STP交换机每一个端口都对应一个开销值，这个值表示数据通过端口发送时的开销，这个值与端口带宽有关，带宽越高，开销值越小。根路径开销是根据交换机之间的网段来说的，本地路径的开销也叫端口开销是针对本地的物理链路来说的相关的IETF的规定为。
【笔记-Git】git commit
zhaoyaxuan001的博客
10-16 300
git commit是Git版本控制系统中的基本命令，用于将索引区（暂存区）中的改动正式记录（或“提交”）到本地仓库的历史记录中。该命令是版本控制过程中的一个重要步骤，标记项目在某个时间点的状态，使得用户可以追踪和回溯代码的变化。
ROS理论与实践学习笔记——6 ROS机器人导航（仿真）之导航实现
心有所信，方能远行！
10-16 1097
ROS机器人导航（仿真）主要包括机器人设置、SLAM构图、代价地图和导航模块四个部分。机器人首先通过里程计和激光雷达（或深度相机）提供运动数据和环境感知信息，接着使用Gmapping算法构建二维栅格地图。在此基础上，生成全局和本地代价地图，代价地图包含静态地图层、障碍物层和膨胀层等信息，用于路径规划和避障。最终，move_base 模块通过全局路径规划生成长距离的最优路径，并利用本地路径规划实时调整和避障，使机器人安全地到达目标点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值