JUC | JUC线程间的通信

于 2022-11-09 19:45:34 发布
阅读量242 收藏
点赞数 1
文章标签： java c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mxyuanmx/article/details/127622560
版权
本文深入探讨了Java中线程间通信的概念，从基础的wait/notify机制到使用Condition实现定制化通信。通过实例分析了线程间的同步问题，包括虚假唤醒的解决方法，并展示了如何确保多线程按特定顺序执行的技巧。内容涵盖线程通信模型、条件对象、避免虚假唤醒以及顺序调用的实现策略。
摘要由CSDN通过智能技术生成

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

JUC | JUC线程间的通信

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

一、线程间通信

1.线程通信基础

先来简单案例：

​ 两个线程操作一个初始值为0的变量，实现一个线程对变量增加1，一个线程对变量减少1，交替10轮。

线程间通信模型：

  1. 生产者+消费者
  2. 通知等待唤醒机制

多线程编程模板中：
4. 判断
5. 干活
6. 通知

代码实现：

class ShareDataOne {
    private Integer number = 0;

    /**
     *  增加1
     */
    public synchronized void increment() throws InterruptedException {
        // 1. 判断
        if (number != 0) {
            this.wait();
        }

        // 2. 干活
        number++;
        System.out.println(Thread.currentThread().getName() + ": " + number);

        // 3. 通知
        this.notifyAll();
    }

    /**
     * 减少1
     */
    public synchronized void decrement() throws InterruptedException {
        // 1. 判断
        if (number != 1) {
            this.wait();
        }

        // 2. 干活
        number--;
        System.out.println(Thread.currentThread().getName() + ": " + number);

        // 3. 通知
        this.notifyAll();
    }
}

/**
 * 现在两个线程，
 * 可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 交替，来10轮。
 *
 * 笔记：Java里面如何进行工程级别的多线程编写
 * 1 多线程变成模板（套路）-----上
 *    1.1  线程    操作    资源类
 *    1.2  高内聚  低耦合
 * 2 多线程变成模板（套路）-----中
 *    2.1  判断
 *    2.2  干活
 *    2.3  通知
 */
public class NotifyWaitDemo {

    public static void main(String[] args) {
        ShareDataOne shareDataOne = new ShareDataOne();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AAA").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BBB").start();

    }
}

部分打印结果：AAA和BBB交互执行，执行结果是1 0 1 0… 一共10轮

AAA: 1
BBB: 0
AAA: 1
BBB: 0
AAA: 1
BBB: 0
AAA: 1
BBB: 0
。。。。

如果换成4个线程会怎样？
改造mian方法，加入CCC和DDD两个线程：

    public static void main(String[] args) {
        ShareDataOne shareDataOne = new ShareDataOne();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AAA").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BBB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CCC").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "DDD").start();
    }

打印结果，依然会有概率是，10101010…。

但是，多执行几次，也会出现错乱的现象：

AAA: 1
BBB: 0
CCC: 1
AAA: 2
CCC: 3
BBB: 2
CCC: 3
DDD: 2
AAA: 3
DDD: 2
CCC: 3
BBB: 2

2. 虚假唤醒

换成4个线程会导致错误，虚假唤醒

原因：在java多线程判断时，不能用if，程序出事出在了判断上面。

注意，消费者被唤醒后是从wait()方法（被阻塞的地方）后面执行，而不是重新从同步块开头。

如下图： 出现-1的情况分析！
在这里插入图片描述
解决虚假唤醒：查看API，java.lang.Object的wait方法
在这里插入图片描述

中断和虚假唤醒是可能产生的，所以要用loop循环，if只判断一次，while是只要唤醒就要拉回来再判断一次。

if换成while

class ShareDataOne {
    private Integer number = 0;

    /**
     *  增加1
     */
    public synchronized void increment() throws InterruptedException {
        // 1. 判断
        while (number != 0) {
            this.wait();
        }

        // 2. 干活
        number++;
        System.out.println(Thread.currentThread().getName() + ": " + number);

        // 3. 通知
        this.notifyAll();
    }

    /**
     * 减少1
     */
    public synchronized void decrement() throws InterruptedException {
        // 1. 判断
        while (number != 1) {
            this.wait();
        }

        // 2. 干活
        number--;
        System.out.println(Thread.currentThread().getName() + ": " + number);

        // 3. 通知
        this.notifyAll();
    }
}

/**
 * 现在两个线程，
 * 可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 交替，来10轮。
 *
 * 笔记：Java里面如何进行工程级别的多线程编写
 * 1 多线程变成模板（套路）-----上
 *    1.1  线程    操作    资源类
 *    1.2  高内聚  低耦合
 * 2 多线程变成模板（套路）-----中
 *    2.1  判断
 *    2.2  干活
 *    2.3  通知
 * 3 多线程编程模板（套路）-----下
 *    防止虚假唤醒（while）
 */
public class NotifyWaitDemo {

    public static void main(String[] args) {
        ShareDataOne shareDataOne = new ShareDataOne();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AAA").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BBB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CCC").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "DDD").start();
    }
}

再次测试，完美解决

3.线程通信（Condition）

对标synchronized：
在这里插入图片描述
Condition：查看API，java.util.concurrent.locks
在这里插入图片描述
并提供了实现案例：
在这里插入图片描述

使用Condition实现线程通信，改造之前的代码（只需要改造ShareDataOne）：**删掉increment和decrement方法的synchronized
class ShareDataOne {
private Integer number = 0;

final Lock lock = new ReentrantLock(); // 初始化lock锁
final Condition condition = lock.newCondition(); // 初始化condition对象

/**
 *  增加1
 */
public void increment() throws InterruptedException {
    lock.lock(); // 加锁
    try {
        // 1. 判断
        while (number != 0) {
            // this.wait();
            condition.await();
        }

        // 2. 干活
        number++;
        System.out.println(Thread.currentThread().getName() + ": " + number);

        // 3. 通知
        // this.notifyAll();
        condition.signalAll();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}

/**
 * 减少1
 */
public void decrement() throws InterruptedException {
    lock.lock();
    try {
        // 1. 判断
        while (number != 1) {
            // this.wait();
            condition.await();
        }

        // 2. 干活
        number--;
        System.out.println(Thread.currentThread().getName() + ": " + number);

        // 3. 通知
        //this.notifyAll();
        condition.signalAll();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}

}

4. 定制化调用通信

通过案例来分析讲解定制化调用通信
案例：

​ 多线程之间按顺序调用，实现A->B->C。三个线程启动，要求如下：

​ AA打印5次，BB打印10次，CC打印15次

​ 接着

​ AA打印5次，BB打印10次，CC打印15次

​ 。。。打印10轮

思路：

  1. 有一个锁Lock，3把钥匙Condition
  2. 有顺序通知（切换线程），需要有标识位
  3. 判断标志位
  4. 输出线程名 + 内容
  5. 修改标识符，通知下一个

接下来将案例实现：
在这里插入图片描述
内容：

class ShareDataTwo {

    private Integer flag = 1; // 线程标识位，通过它区分线程切换
    private final Lock lock = new ReentrantLock();
    private final Condition condition1 = lock.newCondition();
    private final Condition condition2 = lock.newCondition();
    private final Condition condition3 = lock.newCondition();

    public void print5() {
        lock.lock();
        try {
            while (flag != 1) {
                condition1.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + (i + 1));
            }
            flag = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print10() {
        lock.lock();
        try {
            while (flag != 2) {
                condition2.await();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + (i + 1));
            }
            flag = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print15() {
        lock.lock();
        try {
            while (flag != 3) {
                condition3.await();
            }
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + (i + 1));
            }
            flag = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

/**
 * 多线程之间按顺序调用，实现A->B->C
 * 三个线程启动，要求如下：
 * AA打印5次，BB打印10次，CC打印15次
 * 接着
 * AA打印5次，BB打印10次，CC打印15次
 * ......来10轮
 */
public class ThreadOrderAccess {

    public static void main(String[] args) {

        ShareDataTwo sdt = new ShareDataTwo();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                sdt.print5();
            }
        }, "AAA").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                sdt.print10();
            }
        }, "BBB").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                sdt.print15();
            }
        }, "CCC").start();
    }
}

总结

蕤荥
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JUC中的线程通信 Condition
喻志强的博客
06-20 238
JUC中的线程通信 Lock锁Condition线程通信
JUC以及并发，线程同步，线程安全的概念加深
喻志强的博客
06-18 274
JUC JUC：就是JDK给我们提供好的一个工具包，提供了很多用于处理并发的类和接口。包名是 java.util.concurrent .取前三个字母就是JUC 我们先大致看一眼这个包里都有啥 可以看到，JUC包中有很多类和接口，我们之前用的Callable,FutureTask以及用来简化线程休眠的TimeUnit都在这个包中。 所以说，基本上，不管你是Android开发还是Java开发，只要涉及到多线程并发的知识，这个包的代码你是一定会用到的，所以java.util.concurrent这个包里的类和
JUC - 线程通信：
上山打卤面的博客
03-08 196
线程通信： 面试题：两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B…5152Z 上面的问题方式有非常多种 但是万变不离其宗 就是多线程顺序输出 我们都知道 多线程的启动不是按照start方法在代码中的先后顺序进行执行的 线程启动的顺序是不确定的 多线程编程就是要将不确定的 变为确定 （这也是多线程的魅力）这必然需要一套线程之间的通信机制 – 也就是通知等待唤醒机...
JUC之线程通信
weixin_38568503的博客
03-04 481
Java多线程的wait()方法和notify()方法 这两个方法是成对出现和使用的，要执行这两个方法，有一个前提就是，当前线程必须获其对象的monitor（俗称“锁”），否则会抛出IllegalMonitorStateException异常，所以这两个方法必须在同步块代码里面调用。 wait()：阻塞当前线程 notify()：唤起被wait()阻塞的线程 ...
JUC如是实现线程之间的通信
weixin_42022924的博客
10-29 349
1. Condition 组件 在jdk中，synchronized可以实现线程通信，wait/notify 方法；在Condition中提供了多线程协调的通信，可以让某一个线程等待，只有条件满足才能被唤醒； 1.1 Condition使用 ...
JUC-线程间通信
Logan的博客
08-23 145
3 线程间通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基于这两种模 型来实现的。 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求 用线程间通信 3.1 synchronized 方案 /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 * * @param args */ public static void ma
JUC- 线程间通信
che_j的博客
10-20 200
两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1
JUC代码演示 Java多线程并发
最新发布
05-03
了解和掌握线程的基本概念（如用户线程与守护线程）、同步机制（如`synchronized`和`Lock`接口），以及线程间通信的方法对于开发高质量的并发应用至关重要。希望本篇文章能帮助读者更好地理解和运用Java多线程并发的...
JUC多线程学习个人笔记
07-08
线程是进程内的执行单元，线程间的通信和资源共享更为便捷，但共享数据可能导致并发问题。 9. **管程（Monitor）**：Monitor是Java中的一种同步机制，确保同一时间只有一个线程可以访问特定的代码块或数据。Monitor...
juc:Java多线程学习笔记源码部分
04-13
共享资源在线程间的通信比较容易。 线程开销更小。 进程和线程的区别？ 进程是一个独立的运行环境，而线程是在进程中执行的一个任务。他们两个本质的区别是是否单独占有内存地址空间及其它系统资源（比如I/O）。 ...
JUC之线程间的通信
wdjnb的博客
12-30 405
线程通信 创建资源类，在资源类中创建属性和操作方法 在资源类里面操作 判断 干活 通知 创建多个线程，调用资源类的操作方法 线程通信的实现例子： 两个线程，实现对一个初始变量为0进行操作，一个线程对其+1，一个线程对其-1，使得变量结果不改变 使用Synchronized实现的线程通信： package com.JUC; /** * 创建资源类 */ class Share{ //初始值 private int number = 0; //创.
JUC之线程间通信
Y_Ace的博客
04-15 142
前言 我们知道了什么是线程, 知道了什么是锁, 但是怎样编写多线程程序呢? 通过下面的文章将告诉大家编写一个简单的多线程程序需要那几步。 线程间通信 谈到线程间通信就不得不说一个经典的生产者-消费者模型, 我们假定这样一个场景: 一个小小的饮品店, 桌子太小了每次只能放一杯饮品 桌子上没有饮品的时候顾客就会等待 桌子上有饮品的时候店长就不做了(很佛系) 我们尝试用代码实现以下这个场景: 把饮品店, 饮品, 做饮品, 取饮品给抽象出来 class IceCream{ //饮品 priv
【第二章】JUC之线程间通信&线程间定制化调用通信
林大侠
10-29 304
笔记大纲 线程间通信 经典生产者与消费者案例问题（synchronized） 经典生产者与消费者案例问题(新增至四个线程) 经典生产者与消费者案例问题（while取代if） JAVA8新版实现（Lock-对标实现&Condition） 线程间定制化调用通信（案例） 一、线程间通信 1.经典生产者与消费者案例问题（synchronized）   现在有两个线程，要实现一个...
JUC笔记(三) --- 线程的通信
qq_57115378的博客
10-27 322
Java线程间的通信
Java学习 --- JUC线程通信
qq_46093575的博客
03-22 454
案例：使用两个线程，实现对一个初始值是0的变量操作，一个线程对其进行加一操作，另一个线程对其进行减一操作，这个过程就是线程通信。三步骤：判断、干活、通知上面的代码存在虚假唤醒运行结果：原因是wait方法引起的：由于wait方法的特点就是在那里睡就在那里醒，会导致if判断条件失效。......
Java-9.26-next
Desperate_gh的博客
09-26 251
使用线程 有三种使用线程的方法： 实现 Runnable 接口； 实现 Callable 接口； 继承 Thread 类。 实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以理解为任务是通过线程驱动从而执行的。 实现 Runnable 接口 需要实现接口中的 run() 方法。 public class MyRunnable implements Runnable { @Override
JUC学习（二）- 线程间的通信
weixin_45716265的博客
10-20 141
一、线程间的通信 （一）多线程交互的虚假唤醒 （1）虚假唤醒重现 //资源类 class AirConditioner{ private int number = 0; public synchronized void increment() throws InterruptedException { //1判断 if(number != 0) { this.wait(); } //2干活
JUC-009-Condition控制线程通信
qq_33605778的博客
02-07 290
概述 Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。 在 Condition 对象中，与 wait、notify 和 notifyAl
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
这个模式可以很好地解决多线程间的数据同步和通信问题。 在课程的后续部分，介绍了8锁的现象。这是指在多线程环境下，对同一个对象的不同同步方法进行调用时，线程之间可能发生的竞争条件。了解8锁的现象可以帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值