JUC高并发编程(04) -- 线程间定制化通信

最新推荐文章于 2025-04-17 21:51:24 发布
原创 最新推荐文章于 2025-04-17 21:51:24 发布 · 280 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文详细讲解了如何使用Java并发工具包中的ReentrantLock和Condition接口，实现实例化的线程间定制化通信，包括AA、BB和CC线程按顺序轮流打印。通过lock(), newCondition(), await(), signal()等方法协调多线程操作，确保任务按预期顺序执行。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JUC高并发编程

四、线程间定制化通信

4.1）线程间定制化通信案例

A线程打印2次AA，B线程打印4次BB，C线程打印6次CC，按照此顺序循环3轮

4.2）线程间定制化通信案例代码实现

4.2.1）Lock接口

public interface Lock {
    void lock();
​
    void lockInterruptibly() throws InterruptedException;
​
    boolean tryLock();
 
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
​
    void unlock();
​
    Condition newCondition();
}

4.2.1.1）lock()

lock()方法是平常使用得最多的一个方法，就是用来获取锁。

如果锁已被其他线程获取，则进行等待；采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。

因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

通常使用Lock 来进行同步的话，是以下面这种形式去使用的：

Lock lock = new ReentrantLock();
//上锁 
lock.lock(); 
try{    
  //处理任务 
}catch(Exception ex){
   ...
}finally{
 //释放锁 
 lock.unlock();  
}

4.2.1.2）newCondition

关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待/通知模式，Lock锁的newContition()方法返回Condition对象，Condition类也可以实现等待/通知模式。

用notify()通知时，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择性通知，Condition比较常用的两个方法：

  1. await()会使当前线程等待,同时会释放锁,当其他线程调用signal()时,线程会重 新获得锁并继续执行；

  2. signal()用于唤醒一个等待的线程。

注意：在调用Condition的await()/signal()方法前，也需要线程持有相关的Lock锁，调用await()后线程会释放这个锁，在singal()调用后会从当前 Condition对象的等待队列中，唤醒一个线程，唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

4.2.2）代码实现

流程分析如下图：

代码如下：

package com.study.lock;
​
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
​
//第一步 创建资源类
class ShareResource {
    //定义标志位
    // 1 AA     2 BB     3 CC
    private int flag = 1;
​
    //创建Lock锁
    private Lock lock = new ReentrantLock();
​
    //创建三个condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();
​
    //打印2次，参数第几轮
    public void print2(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断：flag值是否是1，如果不是1，等待
            while (flag != 1) {
                //等待
                c1.await();
            }
            //干活：如果flag值是1，就输出信息
            for (int i = 1; i <= 2; i++) {
                System.out.println("当前线程名：" + Thread.currentThread().getName() + " :: " + i + " ：轮数：" + loop);
            }
            //通知：通知BB线程
            //修改标志位为 2 -> BB
            flag = 2;
            //通知BB线程
            c2.signal();
        } finally {
            //释放锁
            lock.unlock();
        }
    }
​
    //打印4次，参数第几轮
    public void print4(int loop) throws InterruptedException {
        lock.lock();
        try {
            //判断：flag值是否是2，如果不是2，等待
            while (flag != 2) {
                c2.await();
            }
            //干活：如果flag值是2，就输出信息
            for (int i = 1; i <= 4; i++) {
                System.out.println("当前线程名：" + Thread.currentThread().getName() + " :: " + i + " ：轮数：" + loop);
            }
            //通知：通知CC线程
            //修改标志位为 3 -> CC
            flag = 3;
            //通知CC线程
            c3.signal();
        } finally {
            lock.unlock();
        }
    }
​
    //打印6次，参数第几轮
    public void print6(int loop) throws InterruptedException {
        lock.lock();
        try {
            //判断：flag值是否是3，如果不是3，等待
            while (flag != 3) {
                c3.await();
            }
            //干活：如果flag值是3，就输出信息
            for (int i = 1; i <= 6; i++) {
                System.out.println("当前线程名：" + Thread.currentThread().getName() + " :: " + i + " ：轮数：" + loop);
            }
            //通知：通知AA线程
            //修改标志位为 1 -> AA
            flag = 1;
            //通知AA线程
            c1.signal();
        } finally {
            lock.unlock();
        }
    }
}
​
public class ThreadDemo3 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        // 创建线程 AA
        new Thread(() -> {
            // 循环调用 3 次
            for (int i = 1; i <= 3; i++) {
                try {
                    shareResource.print2(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        // 创建线程 BB
        new Thread(() -> {
            // 循环调用 3 次
            for (int i = 1; i <= 3; i++) {
                try {
                    shareResource.print4(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();
        // 创建线程 CC
        new Thread(() -> {
            // 循环调用 3 次
            for (int i = 1; i <= 3; i++) {
                try {
                    shareResource.print6(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();
    }
}

输出：

com.study.lock.ThreadDemo3
当前线程名：AA :: 1 ：轮数：1
当前线程名：AA :: 2 ：轮数：1
当前线程名：BB :: 1 ：轮数：1
当前线程名：BB :: 2 ：轮数：1
当前线程名：BB :: 3 ：轮数：1
当前线程名：BB :: 4 ：轮数：1
当前线程名：CC :: 1 ：轮数：1
当前线程名：CC :: 2 ：轮数：1
当前线程名：CC :: 3 ：轮数：1
当前线程名：CC :: 4 ：轮数：1
当前线程名：CC :: 5 ：轮数：1
当前线程名：CC :: 6 ：轮数：1
当前线程名：AA :: 1 ：轮数：2
当前线程名：AA :: 2 ：轮数：2
当前线程名：BB :: 1 ：轮数：2
当前线程名：BB :: 2 ：轮数：2
当前线程名：BB :: 3 ：轮数：2
当前线程名：BB :: 4 ：轮数：2
当前线程名：CC :: 1 ：轮数：2
当前线程名：CC :: 2 ：轮数：2
当前线程名：CC :: 3 ：轮数：2
当前线程名：CC :: 4 ：轮数：2
当前线程名：CC :: 5 ：轮数：2
当前线程名：CC :: 6 ：轮数：2
当前线程名：AA :: 1 ：轮数：3
当前线程名：AA :: 2 ：轮数：3
当前线程名：BB :: 1 ：轮数：3
当前线程名：BB :: 2 ：轮数：3
当前线程名：BB :: 3 ：轮数：3
当前线程名：BB :: 4 ：轮数：3
当前线程名：CC :: 1 ：轮数：3
当前线程名：CC :: 2 ：轮数：3
当前线程名：CC :: 3 ：轮数：3
当前线程名：CC :: 4 ：轮数：3
当前线程名：CC :: 5 ：轮数：3
当前线程名：CC :: 6 ：轮数：3

JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
尚硅谷—高级—JUC 高并发编程
张老师的博客
07-18 1016
目录 一：JUC 概述 二：Lock 接口 三：线程间通信 四：线程间定制化通信 五：集合的线程安全 六：多线程锁 七：Callable 接口 八：JUC 强大的辅助类 九：ReentranReadWriteLock 读写锁 十：BlockingQueue 阻塞队列 十一：ThreadPool 线程池 十二：Fork / Join 分支合并框架 十三：CompletableFutrue 异步回调 一：JUC 概述 1）什么是 JUC： ...
线程间定制化通信问题
weixin_45417821的博客
07-14 208
文章目录案例分析案例介绍代码实现 案例分析 上图： 案例介绍 问题: A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照 此顺序循环 10 轮 代码实现 package com.lock; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; //第一步，
线程间定制化通信（ReentrantLock）
linsa_pursuer的博客
04-20 249
线程间定制化通信（ReentrantLock）
线程间定制化通信
我的博客
09-10 287
synchronized实现线程间通信的案例如果有多个线程那么就无法指定线程执行的顺序，我们可以使用Lock锁的Condition 实现线程定制化通信 实例： A线程打印2次A，B线程打印3次B，C线程打印5次C,按照此顺序循环10轮 思路：创建三个线程给每个线程设置一个标志位 线程A判断flag=0，打印2次，修改flag=1,通知线程B 线程B判断flag=1，打印3次，修改flag=2,通知线程C 线程C判断flag=2，打印5次，修改flag=0,通知线程A package com.dongguo.
JUC---线程间定制化通信
myjess’s blog
07-23 275
此博客案例来自尚硅谷JUC视频 一、线程间的通信 实现两个线程（AA、BB），使得AA线程+1，BB线程-1 package com.jess.sync; /** * @program: JUC * @description: 线程间的通信 * @author: Jess * @create: 2021-07-23 13:48 **/ //第一步 创建资源类，定义属性和操作方法 class Share { //初始值 private int number = 0; //.
JUC并发编程
liuyongheng1991的博客
07-31 567
JUC 并发编程 来源：【尚硅谷】大厂必备技术之JUC并发编程2021最新版 1 什么是 JUC 1.1 JUC 简介 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。 JUC 就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包， JDK 1.5 开始出现的。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xzXLRLL8-1627717457873)(assets2/1627185831660.png)]
并发编程JUC
最新发布
m0_46159536的博客
04-17 600
程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）线程更轻量，线程上下文切换成本一般上要比进程上下文切换低(上下文切换指的是从一个线程切换到另一个线程)，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行。
JUC-并发
HBryce24的博客
02-06 1238
并发面试题
题目：顺序打印:a打印5次；b打印10次；c打印15次，循环10次
02-07 259
public class SyncAndReentrantLockDemo { public static void main(String[] args) { final ShareResource shareResource = new ShareResource(); for (int i = 0; i < 11; i++) { } Thread thread = new Thread(new Runnable() { .
多线程通信（LOCK）
Within的博客
07-12 173
class LShare{ private int number = 0; private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); public void incr() throws InterruptedException { lock.lock(); try { while (num.
JUC-线程间定制化通讯
qq_42296117的博客
08-09 248
默认的情况下cpu是在随机切换线程，那你邮箱多个线程可以有规律的执行，那么多线程之间需要一些协调通信； Demo：多线程按照顺序调用：A->B->C 三个线程启动，要求： AA答应5次，BB答应10次，CC打印15次 接着 AA答应5次，BB答应10次，CC打印15次 … 就这样重复10轮 需要线程按照这就涉及到信号量： 实现： /** * 多线程按循序调用，实现A->B->C * 三个线程启动，要求： * AA答应5次，BB答应10次，CC打印15次 * 接着 * A
JUC并发编程之线程间通信、线程间定制化通信
maxker的博客
12-26 162
线程之间的通讯：synchronized 实现案例、虚假唤醒问题、Lock 实现案例，线程间定制化通信（单标志法存在的问题）。
线程间定制化调用通信—— 1 高内聚低耦合的前提下，线程操作资源类 2 判断/干活/通知 3 多线程交互中，必须要防止多线程的虚假唤醒，也即（判断只用while，不能用if）
qq_39368007的博客
12-01 242
生产者与消费者模式 一个生产者与一个消费者 题目：现在有两个线程，可以操作初始值为0的一个变量，实现一个线程对该变量加1，另一个线程对该变量减1，这两个线程的操作加一.减一交替，进行10轮，变量的初始值为0 高内聚低耦合的前提下，线程操作资源类 package com.dym.juc; class AirConditioner{ private int number=0; public synchronized void increment() throws Inte...
[Java SDK] [多线程] Java中线程的定制化通信
OxYGC
08-21 332
通过线程配合sleep不加锁定义状态变量(非线程安全,可能会少打印)启动三个线程，按照如下要求:AA打印5此，BB打印10次，CC打印15次，一共进行10轮while(!
JUC- 线程间定制化通信
che_j的博客
10-28 201
A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照 此顺序循环 10 轮
线程间定制化通信---按顺序执行线程
weixin_40228600的博客
01-23 133
AA线程打印5次，BB打印6次，CC打印3次。
4_线程间定制化通信
root_zhb的博客
09-16 166
场景： A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照此顺序循环 10 轮 解决：给每个线程定义一个标志位，通过标志位完成定制化通信 编码流程 上锁    判断条件（防止虚假唤醒），若不满足，conditionA.await();    //具体的逻辑    修改标志位    通过 Condition 唤醒指定线程 解锁（finally） class DemoClass{ //通信对象:0--打印 A 1---打印 B 2----打印 C priva
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值