JUC之线程间通信

最新推荐文章于 2022-11-09 19:45:34 发布
最新推荐文章于 2022-11-09 19:45:34 发布
阅读量99 收藏
点赞数
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_Ace/article/details/124203191
版权

前言

我们知道了什么是线程, 知道了什么是锁, 但是怎样编写多线程程序呢? 通过下面的文章将告诉大家编写一个简单的多线程程序需要那几步。

线程间通信

谈到线程间通信就不得不说一个经典的生产者-消费者模型, 我们假定这样一个场景:

  1. 一个小小的饮品店, 桌子太小了每次只能放一杯饮品
  2. 桌子上没有饮品的时候顾客就会等待
  3. 桌子上有饮品的时候店长就不做了(很佛系)

我们尝试用代码实现以下这个场景:

  1. 把饮品店, 饮品, 做饮品, 取饮品给抽象出来

    class IceCream{
    //饮品
    private static int water = 0;
    //做饮品
    void produce() {}
    //取饮品
    void consume() {}
}

  2. 方法的具体实现, 考虑多线程操作

    class IceCream{
    //饮品
    private static int water = 0;
    //做饮品
    synchronized void produce() throws InterruptedException {
        //判断桌子上有没有饮品, 有就不做了
        if (water != 0) {
            this.wait();
        }
        //没有咱就做一杯
        water++;
        System.out.println(Thread.currentThread().getName() + " : " + water);
        //告诉消费者可以取了
        this.notifyAll();
    }
    //取饮品
    synchronized void consume() throws InterruptedException {
        //判断桌子上有没有饮品, 没有就等着
        if (water != 1) {
            this.wait();
        }
        //有就取走
        water--;
        System.out.println(Thread.currentThread().getName() + " : " + water);
        //告诉店家该做了
        this.notifyAll();
    }
}

  3. 来个main()方法调用一下

    public class Test{
    public static void main(String[] args) {
        //创建资源类
        IceCream ic = new IceCream();
        //创建生产线程
        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    ic.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "produce1").start();
        //创建消费线程
        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    ic.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "consume1").start();
    }
}

    运行一下:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6YXxRS8H-1650025517205)(/img/2022-03-26/11.png)]

    发现非常和睦, produce1做一杯, consume1买一杯。

这时我们需求升级了, 多来个做饮品的, 买饮品的也多排了一队, 但是桌子还是那么大, 简单, 我们再来两个线程就好

public class Test{
    public static void main(String[] args) {
        //创建资源类
        IceCream ic = new IceCream();
        //创建生产线程1
        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    ic.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "produce1").start();
        //创建生产线程2
        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    ic.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "produce2").start();
        //创建消费线程1
        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    ic.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "consume1").start();
        //创建消费线程2
        new Thread(()->{
            for (int i = 0; i <= 10; i++) {
                try {
                    ic.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "consume2").start();
    }
}

看一下运行结果:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6b9zKnmE-1650025517206)(/img/2022-03-26/12.png)]

出大问题, 不是说好的桌子上只能放一杯么, 为什么会出现这种问题呢, 那是因为在程序中发生了虚假唤醒:

之前说过, wait()这个方法是在哪里停下就在那里开始, 回头看一眼代码两个方法中进行判断的地方

//判断桌子上有没有饮品, 有就不做了
if (water != 0) {
    this.wait();//在这里醒来就相当于判断已经结束, 要执行下面的代码块了, 但是这是重新进来的, 应该再次进行判断
}

//判断桌子上有没有饮品, 没有就等着
if (water != 1) {
    this.wait();//在这里醒来就相当于判断已经结束, 要执行下面的代码块了, 但是这是重新进来的, 应该再次进行判断
}

我们使用while循环替代if, 这样每次醒过来就会重新进行判断, 改完之后的代码如下:

class IceCream{
    //饮品
    private static int water = 0;
    //做饮品
    synchronized void produce() throws InterruptedException {
        //判断桌子上有没有饮品, 有就不做了
        while (water != 0) {//使用while循环解决虚假唤醒问题
            this.wait();
        }
        //没有咱就做一杯
        water++;
        System.out.println(Thread.currentThread().getName() + " : " + water);
        //告诉消费者可以取了
        this.notifyAll();
    }
    //取饮品
    synchronized void consume() throws InterruptedException {
        //判断桌子上有没有饮品, 没有就等着
        while (water != 1) {//使用while循环解决虚假唤醒问题
            this.wait();
        }
        //有就取走
        water--;
        System.out.println(Thread.currentThread().getName() + " : " + water);
        //告诉店家该做了
        this.notifyAll();
    }
}

再次看一下运行结果:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-90nRF3zA-1650025517207)(/img/2022-03-26/13.png)]

又和睦起来了!

多线程编程步骤

经过上面的那个案例, 可以总结一下四个步骤:

  1. 创建资源类, 在资源类中创建共享属性和操作方法
  2. 在资源类操作方法: 判断、操作、通知
  3. 创建多个线程, 调用资源类的操作方法
  4. 防止虚拟唤醒问题

Lock接口版

既然synchronized可以实现上面的案例, 那么Lock接口肯定也可以实现, 使用Condition的两个方法实现线程等待和唤醒

class IceCream{
    //饮品
    private static int water = 0;
    //创建可重入锁
    private Lock lock = new ReentrantLock();
    //获得condition实例
    private Condition condition = lock.newCondition();
    //做饮品
    void produce() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断桌子上有没有饮品, 有就不做了
            while (water != 0) {//使用while循环解决虚假唤醒问题
                condition.await();
            }
            //没有咱就做一杯
            water++;
            System.out.println(Thread.currentThread().getName() + " : " + water);
            //告诉消费者可以取了
            condition.signalAll();
        } finally {
            //释放锁
            lock.unlock();
        }
    }
    //取饮品
    void consume() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断桌子上有没有饮品, 没有就等着
            while (water != 1) {//使用while循环解决虚假唤醒问题
                condition.await();
            }
            //有就取走
            water--;
            System.out.println(Thread.currentThread().getName() + " : " + water);
            //告诉店家该做了
            condition.signalAll();
        } finally {
            //释放锁
            lock.unlock();
        }
    }
}

看一下运行结果:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BW4xouAY-1650025517208)(/img/2022-03-26/14.png)]

完美复刻!

线程定制化通信

上面案例的结果都有一个特点, 两个生产者和两个消费者出现的很乱, 有没有可能让线程间按照我们想要的顺序运行呢?

来看一个简单案例, 要求是

  • AA, BB, CC三个线程, 每个线程调用一个方法
  • 执行顺序是AA->BB->CC
  • 循环执行10轮

看一下思路

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BjtJpL7H-1650025517209)(/img/2022-03-26/15.png)]

根据这个思路, 来编写代码

class ShareResource {
    //定义标志位
    private static int flag = 1;
	//创建可重入锁
    private Lock lock = new ReentrantLock();
    //创建三个condition
    Condition cA = lock.newCondition();
    Condition cB = lock.newCondition();
    Condition cC = lock.newCondition();

    //A方法
    public void methodA(int loop) {
        lock.lock();
        try {
            //判断
            while (flag != 1) {
                cA.await();
            }
            System.out.println(Thread.currentThread().getName() + "methodA : 第" + loop + "轮");
            //设置标志位为2
            flag = 2;
            //cB唤醒
            cB.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //B方法
    public void methodB(int loop) {
        lock.lock();
        try {
            //判断
            while (flag != 2) {
                cB.await();
            }
            System.out.println(Thread.currentThread().getName() + "methodB : 第" + loop + "轮");
            //设置标志位为3
            flag = 3;
            //cC唤醒
            cC.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //C方法
    public void methodC(int loop) {
        lock.lock();
        try {
            //判断
            while (flag != 3) {
                cC.await();
            }
            System.out.println(Thread.currentThread().getName() + "methodC : 第" + loop + "轮");
            //设置标志位为1
            flag = 1;
            //cA唤醒
            cA.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

写个主类测试一下

public class ThreadDemo {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.methodA(i);
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.methodB(i);
            }
        }, "BB").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.methodC(i);
            }
        }, "CC").start();
    }
}

看下运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-egLrg8IH-1650025517209)(/img/2022-03-26/16.png)]

按照我们的需求完美运行, 这就是线程定制化通信!

我的个人主页: www.ayu.link
本文连接: ┏ (゜ω゜)=☞

aYuIsAyU
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC中的线程通信 Condition
喻志强的博客
06-20 224
JUC中的线程通信 Lock锁Condition线程通信
JUC多线程学习个人笔记
07-08
线程是进程内的执行单元，线程间的通信和资源共享更为便捷，但共享数据可能导致并发问题。 9. **管程（Monitor）**：Monitor是Java中的一种同步机制，确保同一时间只有一个线程可以访问特定的代码块或数据。Monitor...
JUC学习（二）- 线程间的通信
weixin_45716265的博客
10-20 134
一、线程间的通信 （一）多线程交互的虚假唤醒 （1）虚假唤醒重现 //资源类 class AirConditioner{ private int number = 0; public synchronized void increment() throws InterruptedException { //1判断 if(number != 0) { this.wait(); } //2干活
JUC- 线程间通信
che_j的博客
10-20 140
两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1
JUC之线程间的通信
wdjnb的博客
12-30 396
线程通信 创建资源类，在资源类中创建属性和操作方法 在资源类里面操作 判断 干活 通知 创建多个线程，调用资源类的操作方法 线程通信的实现例子： 两个线程，实现对一个初始变量为0进行操作，一个线程对其+1，一个线程对其-1，使得变量结果不改变 使用Synchronized实现的线程通信： package com.JUC; /** * 创建资源类 */ class Share{ //初始值 private int number = 0; //创.
JUC高并发编程(03) -- 线程间通信
姜皓的博客
05-08 251
线程间通信
JUC+课程源码+线程操作
09-04
它是并发编程中的重要工具，常用于线程间的通信和数据共享，如`ArrayBlockingQueue`、`LinkedBlockingQueue`和`PriorityBlockingQueue`等。 在`juc_atguigu`这个压缩包中，包含了上述组件的示例代码，通过实际运行...
基于JUC的多线程网页爬虫.zip
03-08
这些工具帮助我们管理线程，控制并发，同步任务执行，以及协调线程间的通信。 1. **ExecutorService**：它是线程池的接口，通过它可以创建、管理和控制线程。`ThreadPoolExecutor`是其最常见的实现，允许自定义...
heima-JUC-资料
最新发布
04-25
8. **线程通信**：`Semaphore`（信号量）、`CountDownLatch`（倒计时器）、`CyclicBarrier`（循环栅栏）和`Phaser`（屏障）等工具类，用于控制线程间的同步和通信，实现特定的并发模式。 9. **Fork/Join框架**：...
JUC学习笔记（Java多线程）
07-04
同步机制是多线程编程中的重要部分，JUC提供了多种工具来实现线程间的同步与通信。`synchronized`关键字是Java内置的同步机制，它可以保证同一时刻只有一个线程访问共享资源。另外，JUC还提供了`Lock`接口，它的实现...
JUC如是实现线程之间的通信
weixin_42022924的博客
10-29 337
1. Condition 组件 在jdk中，synchronized可以实现线程通信，wait/notify 方法；在Condition中提供了多线程协调的通信，可以让某一个线程等待，只有条件满足才能被唤醒； 1.1 Condition使用 ...
JUC之线程通信
weixin_38568503的博客
03-04 470
Java多线程的wait()方法和notify()方法 这两个方法是成对出现和使用的，要执行这两个方法，有一个前提就是，当前线程必须获其对象的monitor（俗称“锁”），否则会抛出IllegalMonitorStateException异常，所以这两个方法必须在同步块代码里面调用。 wait()：阻塞当前线程 notify()：唤起被wait()阻塞的线程 ...
JUC - 线程通信：
上山打卤面的博客
03-08 190
线程通信： 面试题：两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B…5152Z 上面的问题方式有非常多种 但是万变不离其宗 就是多线程顺序输出 我们都知道 多线程的启动不是按照start方法在代码中的先后顺序进行执行的 线程启动的顺序是不确定的 多线程编程就是要将不确定的 变为确定 （这也是多线程的魅力）这必然需要一套线程之间的通信机制 – 也就是通知等待唤醒机...
JUC | JUC线程间的通信
蕤荥的成长博客
11-09 234
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
JUC 三 线程间通信
零零JA
09-03 142
多线程编程模板下： 判断 干活 通知 判断为了防止虚假唤醒， 此处的判断必须用while进行判断而不能用if进行判断，，，if判断为什么会用虚假唤醒，可以仔细考虑清楚。 JUC的线程间通信： 使用： 使用创建好的lock对象创建一个condition对象，Contidion condition =lock.newCondition（...
JUC笔记(三) --- 线程的通信
qq_57115378的博客
10-27 294
Java线程间的通信
JUC-线程间通信
Logan的博客
08-23 116
3 线程间通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基于这两种模 型来实现的。 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求 用线程间通信 3.1 synchronized 方案 /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 * * @param args */ public static void ma
Java学习 --- JUC线程通信
qq_46093575的博客
03-22 389
案例：使用两个线程，实现对一个初始值是0的变量操作，一个线程对其进行加一操作，另一个线程对其进行减一操作，这个过程就是线程通信。三步骤：判断、干活、通知上面的代码存在虚假唤醒运行结果：原因是wait方法引起的：由于wait方法的特点就是在那里睡就在那里醒，会导致if判断条件失效。......
Java-9.26-next
Desperate_gh的博客
09-26 242
使用线程 有三种使用线程的方法： 实现 Runnable 接口； 实现 Callable 接口； 继承 Thread 类。 实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以理解为任务是通过线程驱动从而执行的。 实现 Runnable 接口 需要实现接口中的 run() 方法。 public class MyRunnable implements Runnable { @Override
Java并发编程：JUC线程详解与实践
线程间的通信和同步是Java并发编程的重要部分，Java提供了一系列工具，如`synchronized`关键字、`wait()`, `notify()`, `notifyAll()`方法、`Lock`接口及其实现类（如`ReentrantLock`）、`Semaphore`信号量、`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值