JUC高并发编程(03) -- 线程间通信

原创 已于 2022-05-08 16:49:51 修改 · 330 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-05-08 16:47:53 首次发布
该博客探讨了Java中两种线程间通信的实现方式：synchronized关键字和Lock接口。通过一个数值加减的案例展示了如何使用这两种方式确保线程安全，防止虚假唤醒问题，并详细解释了每个方法的步骤和逻辑。

JUC高并发编程

三、线程间通信

线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。

3.1）线程间通信案例

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

3.1.1）synchronized 方案

package com.study.sync;
​
//第一步 创建资源类，定义属性和操作方法
class Share {
    //初始值
    private int number = 0;
    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        //判断：number值是否是0，如果不是0，等待
        // if (number != 0) {  --> 会产生虚假唤醒问题，即只对第一次进入的条件进行了判断，使用while判断可以避免虚假唤醒
        while (number != 0) {
            //在哪里睡，就在哪里醒
            this.wait();
        }
        //干活：如果number值是0，就+1操作
        number++;
        System.out.println("当前线程名：" + Thread.currentThread().getName() + " :: " + number);
        //通知：通知其他线程
        this.notifyAll();
    }
​
    //-1的方法
    public synchronized void decr() throws InterruptedException {
        //判断：number值是否是1，如果不是1，等待
        // if (number != 1) {  --> 会产生虚假唤醒问题，即只对第一次进入的条件进行了判断，使用while判断可以避免虚假唤醒
        while (number != 1) {
            this.wait();
        }
        //干活：如果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();
        //创建线程
        // 创建线程 AA
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        // 创建线程 BB
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();
        // 创建线程 CC
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();
        // 创建线程 DD
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "DD").start();
    }
}
输出：

com.study.sync.ThreadDemo1
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：CC :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：CC :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：AA :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0

3.1.2）Lock 方案

package com.study.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 {
            //判断：number值是否是0，如果不是0，等待
            // if (number != 0) {  --> 会产生虚假唤醒问题，即只对第一次进入的条件进行了判断，使用while判断可以避免虚假唤醒
            while (number != 0) {
                condition.await();
            }
            //干活：如果number值是0，就+1操作
            number++;
            System.out.println("当前线程名：" + Thread.currentThread().getName() + " :: " + number);
            //通知：通知其他线程
            condition.signalAll();
        } finally {
            //解锁
            lock.unlock();
        }
    }
​
    //-1 方法
    public void decr() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断：number值是否是1，如果不是1，等待
            // if (number != 1) {  --> 会产生虚假唤醒问题，即只对第一次进入的条件进行了判断，使用while判断可以避免虚假唤醒
            while (number != 1) {
                condition.await();
            }
            //干活：如果number值是1，就-1操作
            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();
        // 创建线程 AA
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    // 调用 +1 方法
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        // 创建线程 BB
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    // 调用 -1 方法
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();
        // 创建线程 CC
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    // 调用 +1 方法
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();
        // 创建线程 DD
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    // 调用 -1 方法
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "DD").start();
    }
​
}

输出：

com.study.lock.ThreadDemo2
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：AA :: 1
当前线程名：BB :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0
当前线程名：CC :: 1
当前线程名：DD :: 0

3.2）多线程编程步骤

  1. 创建资源类，在资源类中创建属性和操作方法
  2. 在资源类中操作方法【判断 、干活 、通知 】
  3. 创建多个线程，调用资源类的操作方法
  4. 防止虚假唤醒问题
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
并发编程JUC---------------------------------------------------------------------------------------------
最新发布
m0_46159536的博客
04-17 694
程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）线程更轻量，线程上下文切换成本一般上要比进程上下文切换低(上下文切换指的是从一个线程切换到另一个线程)，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行。
JUC高并发编程3：线程间通信
09-26 1219
本文是尚硅谷JUC高并发教程中线程间通信章节的学习笔记。包括线程间通信、虚假唤醒问题、多线程编程步骤、线程间定制化通信等。供个人学习使用。
JUC之线程间通信
Y_Ace的博客
04-15 211
前言 我们知道了什么是线程, 知道了什么是锁, 但是怎样编写多线程程序呢? 通过下面的文章将告诉大家编写一个简单的多线程程序需要那几步。 线程间通信 谈到线程间通信就不得不说一个经典的生产者-消费者模型, 我们假定这样一个场景: 一个小小的饮品店, 桌子太小了每次只能放一杯饮品 桌子上没有饮品的时候顾客就会等待 桌子上有饮品的时候店长就不做了(很佛系) 我们尝试用代码实现以下这个场景: 把饮品店, 饮品, 做饮品, 取饮品给抽象出来 class IceCream{ //饮品 priv
JUC如是实现线程之间的通信
weixin_42022924的博客
10-29 414
1. Condition 组件 在jdk中，synchronized可以实现线程通信，wait/notify 方法；在Condition中提供了多线程协调的通信，可以让某一个线程等待，只有条件满足才能被唤醒； 1.1 Condition使用 ...
JUC学习（二）- 线程间的通信
weixin_45716265的博客
10-20 202
一、线程间的通信 （一）多线程交互的虚假唤醒 （1）虚假唤醒重现 //资源类 class AirConditioner{ private int number = 0; public synchronized void increment() throws InterruptedException { //1判断 if(number != 0) { this.wait(); } //2干活
JUC - 线程通信：
上山打卤面的博客
03-08 248
线程通信： 面试题：两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B…5152Z 上面的问题方式有非常多种 但是万变不离其宗 就是多线程顺序输出 我们都知道 多线程的启动不是按照start方法在代码中的先后顺序进行执行的 线程启动的顺序是不确定的 多线程编程就是要将不确定的 变为确定 （这也是多线程的魅力）这必然需要一套线程之间的通信机制 – 也就是通知等待唤醒机...
精选资源
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&
精选资源
05-Java多线程并发编程JUC.pdf
09-16
线程间通信主要通过以下几种方法实现： - wait()：使当前执行的线程进入等待状态，并释放对象锁。 - notify()：唤醒在此对象监视器上等待的单个线程。 - notifyAll()：唤醒在此对象监视器上等待的所有线程。 - ...
JUC之线程通信
weixin_38568503的博客
03-04 552
Java多线程的wait()方法和notify()方法 这两个方法是成对出现和使用的，要执行这两个方法，有一个前提就是，当前线程必须获其对象的monitor（俗称“锁”），否则会抛出IllegalMonitorStateException异常，所以这两个方法必须在同步块代码里面调用。 wait()：阻塞当前线程 notify()：唤起被wait()阻塞的线程 ...
JUC-线程间通信
Logan的博客
08-23 209
3 线程间通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基于这两种模 型来实现的。 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求 用线程间通信 3.1 synchronized 方案 /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 * * @param args */ public static void ma
JUC笔记(三) --- 线程的通信
qq_57115378的博客
10-27 392
Java线程间的通信
JUC- 线程间通信
che_j的博客
10-20 255
两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1
JUC | JUC线程间的通信
蕤荥的成长博客
11-09 317
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
JUC之线程间的通信
wdjnb的博客
12-30 454
线程通信 创建资源类，在资源类中创建属性和操作方法 在资源类里面操作 判断 干活 通知 创建多个线程，调用资源类的操作方法 线程通信的实现例子： 两个线程，实现对一个初始变量为0进行操作，一个线程对其+1，一个线程对其-1，使得变量结果不改变 使用Synchronized实现的线程通信： package com.JUC; /** * 创建资源类 */ class Share{ //初始值 private int number = 0; //创.
Java学习 --- JUC线程通信
qq_46093575的博客
03-22 515
案例：使用两个线程，实现对一个初始值是0的变量操作，一个线程对其进行加一操作，另一个线程对其进行减一操作，这个过程就是线程通信。三步骤：判断、干活、通知上面的代码存在虚假唤醒运行结果：原因是wait方法引起的：由于wait方法的特点就是在那里睡就在那里醒，会导致if判断条件失效。......
JUC学习笔记（2）—线程间通信
java_kider的博客
07-31 269
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class ShareData { private int number = 0; private Lock lock = ...
JUC学习之线程通信小Demo
酸奶灬的博客
07-23 312
按照顺序打印A、B、C，共打印五轮： public class Test { public static void main(String[] args) { AlternatePrinting printing = new AlternatePrinting(); new Thread(() -&amp;gt; { for (int i...
Day10 尚硅谷JUC——线程间通信
大白的成长之路
09-18 385
第一步：创建资源类，在资源类创建属性和操作方法第二步：在资源类操作方法判断干活通知第三步：创建多个线程，调用资源类的操作方法第四步：防止虚假唤醒问题。
2021年Java JUC高并发编程技术教程
09-JUC高并发编程-线程间通信-Synchronized实现案例.mp4 在这些课程中，讲解了如何在多线程环境中实现线程间的数据交换和状态同步，重点可能在于理解和应用wait/notify机制以及Lock和Condition的使用。 10-JUC高...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值