Day10 尚硅谷JUC——线程间通信

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量323 收藏 1
点赞数 1
分类专栏： JUC 文章标签： java jvm c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq2632246528/article/details/126925012
版权

我是大白(●—●)，这是我开始学习记录大白Java软件攻城狮晋升之路的第十天。 今天学习的是【尚硅谷】大厂必备技术之JUC并发编程

一、线程通信概述和案例分析

1. 多线程编程步骤（中部）

  1. 第一步：创建资源类，在资源类创建属性和操作方法
  2. 第二步：在资源类操作方法
    1. 判断
    2. 干活
    3. 通知
  3. 第三步：创建多个线程，调用资源类的操作方法
  4. 第四步：防止虚假唤醒问题。

2. 例子

有两个线程，实现对一个初始值是0的变量。一个线程对值+1，另外一个线程对值-1，达到交替执行的效果。
通过Object类的wait()和notify()或者notifyAll()方法实现
wait()：在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前线程等待。
notify()：唤醒在此对象监视器上等待的单个线程。
notifyAll()： 唤醒在此对象监视器上等待的所有线程。

3. Synchronized实现案例

package com.example.demo;

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

    private int number = 0;

    /**
     * 加一的方法
     * @throws InterruptedException
     */
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        if (number != 0) { //判断number的值是否为0，如果不是0，线程等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        this.notifyAll();
    }

    /**
     * 减一的方法
     * @throws InterruptedException
     */
    public synchronized void decr() throws InterruptedException {
        //判断
        if (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();
                } 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();
    }
}

image.png

4. 虚假唤醒问题

当新增了两个线程进行加1减1操作后，代码如下所示：

package com.example.demo;

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

    private int number = 0;

    /**
     * 加一的方法
     * @throws InterruptedException
     */
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
        if (number != 0) { //判断number的值是否为0，如果不是0，线程等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        this.notifyAll();
    }

    /**
     * 减一的方法
     * @throws InterruptedException
     */
    public synchronized void decr() throws InterruptedException {
        //判断
        if (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();
                } 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();
    }
}

最终的结果将会是这样：
image.png
这就是虚假唤醒的情况，当某一时刻C线程进行+1操作后调用了notifyAll()方法，ABD线程均被唤醒且不需要进行判断，因此A线程又执行了+1操作，导致number的值变为了2的情况。
即当一定的条件触发时会唤醒很多在阻塞态的线程，但只有部分的线程唤醒是有用的，其余线程的唤醒是多余的。

5. 解决虚假唤醒问题

官方jdk中推荐的一种方法用来解决虚假唤醒的方法，即将if改为while循环（具体实例可看下一节Lock实现案例代码）：

synchronized (obj) { 
    while (<condition does not hold>) 
    { 
    	obj.wait(timeoutMillis, nanos); 
	} ... // Perform action appropriate to condition or timeout 
}

6. Lock实现案例

使用的主要是Condition接口中的await()和singal()或者singalAll()方法进行通信
await()：造成当前线程在接到信号或被中断之前一直处于等待状态。
singal()：唤醒一个等待线程。
singalAll()：唤醒所有等待线程。

package com.example.demo;

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

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

    private int number = 0;

    //创建Lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    /**
     * 加一的方法
     * @throws InterruptedException
     */
    public void incr() throws InterruptedException {
        lock.lock();
        try{
            //第二步 判断 干活 通知
            while (number != 0) { //判断number的值是否为0，如果不是0，线程等待
                condition.await();;
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    /**
     * 减一的方法
     * @throws InterruptedException
     */
    public synchronized void decr() throws InterruptedException {
        lock.lock();
        try{
            //判断
            while (number != 1) {
                condition.await();
            }
            //干活
            number--;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            //通知其它线程
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}
public class ThreadDemo2 {
    //第三步 创建多个线程，调用资源类的操作方法
    public static void main(String[] args) {
        LShare share = new LShare();
        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();
    }
}

二、线程间定制化通信

image.png
image.png

package com.example.demo;

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

/**
 * 多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下：
 * AA打印5次，BB打印10次，CC打印15次
 * 紧接着
 * AA打印5次，BB打印10次，CC打印15次
 * 。。。。
 * 来10轮
 */
class ShareResource {
    //定义标志位
    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();

    //打印5次，参数第几轮
    public void print5(int loop) {
        lock.lock();
        try {
            //1.判断
            while (flag != 1) {
                c1.await(); //等待
            }
            //2.干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + ",轮数：" + loop);
            }
            //修改标志位
            flag = 2;
            //3.通知BB线程
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10(int loop) {
        lock.lock();
        try {
            while (flag != 2) {
                c2.await();
            }
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + ",轮数：" + loop);
            }
            flag = 3;
            c3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15(int loop) {
        lock.lock();
        try {
            while (flag != 3) {
                c3.await();
            }
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + ",轮数：" + loop);
            }
            flag = 1;
            c1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}


public class SyncAndReentrantLockDemo {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                shareResource.print5(i);
            }
        }, "AA").start();

        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                shareResource.print10(i);
            }
        }, "BB").start();

        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                shareResource.print15(i);
            }
        }, "CC").start();
    }
}
夢想家吖
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
自己整理的多线程JUC笔记尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
尚硅谷JUC笔记
qq_42449963的博客
01-12 1864
一、JUC介绍 1、面试常见问题类别 面向对象、高级语法（1、抽象类和接口有什么区别？2、Java中获得多线程有几种方法？） Java集合类（1、java.util.*中的ArrayList、Vector、LinkedList、TreeMap、HashSet、HashMap、ConcurrentHashMap、CopyOnWriteHashMap、Queue等？2、谈谈你对HashMap的理解，什么是Hash算法，什么是Hash碰撞？） Java多线程（1、Java中获得多线程的方法有几种？） Java
Day8 尚硅谷JUC——JUC概述
大白的成长之路
09-16 642
JUC概述
Day43 尚硅谷JUC——异步回调
大白的成长之路
10-21 485
同步和异步的通俗解释，比如需要找一个A同学，同步的话就是我在这个A同学的位置上一直等着他回来，不能干其他事情，而异步就是告诉其他一个B同学，A同学如果回来了通知我一声，我就可以干别的事情。查看原码分析，它是一个继承Throwable的类，查看其实现类发现都是异常，由此可知，返回的应该是异常。在java中可以使用CompletableFuture类来实现异步调用。通过CompletableFuture类来展示。发现u是一个null，那么他到底是什么含义呢？1.无返回值的异步任务。2.有返回值的异步任务。
Day42 尚硅谷JUC——Fork_Join分支合并框架
大白的成长之路
10-20 638
Fork/Join它可以将一个大的任务拆分成多 个子任务进行并行处理,最后将子任务结果合并成最后的计算结果,并进行输出。Fork：把一个复杂任务进行分拆，大事化小。Join：把分拆任务的结果进行合并1.任务分割：首先Fork/Join框架需要把大的任务分割成足够小的子任务,如果子任务比较大的话还要对子任务进行继续分割2.执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列里获取任务执行。
Day37 尚硅谷JUC——乐观锁、悲观锁、读写锁、锁降级
大白的成长之路
10-16 700
JUC之乐观锁、悲观锁、读写锁、锁降级、表锁和行锁
JUC(六)——线程间通信
云中、漫步的博客
05-01 98
文章目录 现在有两个线程去操作一个初始值为0的变量，要求实现其中一个线程对该变量加1，另外一个线程对该变量减1，要求变量的值只能是0和1，并且要进行交替展示，每个线程来10轮操作。 使用synchronized、wait、notifyAll来解决问题的代码： ...
bilibili尚硅谷周阳老师JUC并发编程与源码分析课程笔记第一章——线程基础知识复习
qq_46601365的博客
02-21 1054
如果用户线程全部结束意味着程序需要完成的业务操作已经结束了，守护线程随着JVM一同结束工作。
尚硅谷JUC并发编程与源码分析
一个沉迷Java，无法自拔的Coder
07-07 574
深入理解JUC并发编程
尚硅谷JUC并发编程与源码分析2022详细笔记
ctflq的博客
06-06 2161
尚硅谷JUC并发编程与源码分析2022版详细笔记
尚硅谷JUC百度云连接
02-15
1. **基础知识讲解**：从基本概念出发，详细介绍线程的创建与启动、线程的状态转换、线程间通信等基础知识点。 2. **核心API介绍**：对JUC中的关键类和接口进行详细解读，包括它们的使用场景和实践案例。 3. **最佳...
22 尚硅谷Java JUC线程高级视频
08-07
教程视频：在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文...
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 452
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 254
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 623
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 293
集合之Map
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 861
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值