尚硅谷JUC高并发编程学习笔记（2）线程通信与集合线程安全

最新推荐文章于 2023-08-20 15:03:36 发布
最新推荐文章于 2023-08-20 15:03:36 发布
阅读量2.4k 收藏 2
点赞数
分类专栏： 多线程并发 文章标签： 安全 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/exodus3/article/details/122768598
版权

一、线程间通信

线程间通信的模型有两种：共享内存和消息传递
线程间的通信具体步骤：（涉及上中下部）

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

1、synchronized案例

操作线程的时候，等待线程使用wait()
通知另外的线程操作用notify()、notifyAll()
假设有两个线程，该线程在执行过程中，判断值（不是该值等待，让其他线程抢），操作值，通知另外一个线程的调度。

通过使用两个线程对0这个值操作，一个线程加1，一个线程减1，交替实现多次

//第一步 创建资源类，定义属性和操作方法
class Share {
    //初始值
    private int number = 0;
    //+1的方法
    public synchronized void incr() throws InterruptedException {
        //第二步 判断 干活 通知
       if(number != 0) { //判断number值是否是0，如果不是0，等待
            this.wait(); //在哪里睡，就在哪里醒
        }
        //如果number值是0，就+1操作
        number++;
        System.out.println(Thread.currentThread().getName()+" :: "+number);
        //通知其他线程
        this.notifyAll();
    }

    //-1的方法
    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 = 1; i <=10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();
    }
}

效果

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

Process finished with exit code 0

如果使用多个线程，添加额外两个线程，且操作要依次执行

new Thread(()->{
    for (int i = 1; i <=10; i++) {
        try {
            share.incr(); //+1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
},"CC").start();

new Thread(()->{
    for (int i = 1; i <=10; i++) {
        try {
            share.decr(); //-1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
},"DD").start();

就会出现这样的情况

AA :: 1
BB :: 0
AA :: 1
BB :: 0
AA :: 1
BB :: 0
AA :: 1
BB :: 0
CC :: 1
AA :: 2
CC :: 3
BB :: 2
CC :: 3
AA :: 4
CC :: 5
DD :: 4
BB :: 3
DD :: 2
CC :: 3
AA :: 4
CC :: 5
DD :: 4
BB :: 3
DD :: 2
CC :: 3
AA :: 4
CC :: 5
DD :: 4
BB :: 3
DD :: 2
CC :: 3
AA :: 4
CC :: 5
DD :: 4
BB :: 3
DD :: 2
AA :: 3
DD :: 2
BB :: 1
DD :: 0

Process finished with exit code 0

主要是虚拟唤醒导致：如果一个线程执行完毕后，通知其他线程，该线程又进入等待睡眠，可能会因为某些原因被唤醒后，if结构的语句就不会判断了，一直往下执行，所以需要将if换成while结构，每次都判断。因为wait在哪里睡眠就在哪里被唤醒，结果被某个异常唤醒了后回不去了，if结构不会在判断了，需要更改为while

while(number != 0) { //判断number值是否是0，如果不是0，等待
    this.wait(); //在哪里睡，就在哪里醒
}

实现中断和虚假唤醒是可能的，需要将其while方法用在循环中。

最后的结果：

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

Process finished with exit code 0
2、Lock案例

使用lock先要创建锁的对象以及通知的对象
放置在资源类中

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

上锁lock.lock();
解锁lock.unlock();
以下都为condition类：
唤醒所有等待的线程signalAll()，带上类名condition.signalAll();
唤醒一个等待线程signal()，带上类名，condition.signal();
造成当前线程在接到信号或者被中断之前一直处于等待状态await()，带上类名，condition.await();

同样是上面的案例题目换成lock

//第一步 创建资源类，定义属性和操作方法
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 {
            //判断
            while (number != 0) {
                condition.await();
            }
            //干活
            number++;
            System.out.println(Thread.currentThread().getName()+" :: "+number);
            //通知
            condition.signalAll();
        }finally {
            //解锁
            lock.unlock();
        }
    }

    //-1
    public void decr() throws InterruptedException {
        lock.lock();
        try {
            while(number != 1) {
                condition.await();
            }
            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();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"DD").start();
    }

}

实现的结果是一样的。

二、线程间定制化通信

所谓定制化通信，需要让线程进行一定的顺序操作

案列：启动三个线程，按照如下要求：
AA打印5此，BB打印10次，CC打印15次，一共进行10轮

具体思路：
每个线程添加一个标志位，是该标志位则执行操作，并且修改为下一个标志位，通知下一个标志位的线程
在这里插入图片描述
代码

//第一步 创建资源类
class ShareResource {
    //定义标志位
    private int flag = 1;  // 1 AA     2 BB     3 CC

    //创建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) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while(flag != 1) {
                //等待
                c1.await();
            }
            //干活
            for (int i = 1; i <=5; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //通知
            flag = 2; //修改标志位 2
            c2.signal(); //通知BB线程
        }finally {
            //释放锁
            lock.unlock();
        }
    }

    //打印10次，参数第几轮
    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 2) {
                c2.await();
            }
            for (int i = 1; i <=10; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 3;
            //通知CC线程
            c3.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印15次，参数第几轮
    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 3) {
                c3.await();
            }
            for (int i = 1; i <=15; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 1;
            //通知AA线程
            c1.signal();
        }finally {
            lock.unlock();
        }
    }
}

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

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

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
    }
}

结果

AA :: 1 ：轮数：1
AA :: 2 ：轮数：1
AA :: 3 ：轮数：1
AA :: 4 ：轮数：1
AA :: 5 ：轮数：1
BB :: 1 ：轮数：1
BB :: 2 ：轮数：1
BB :: 3 ：轮数：1
BB :: 4 ：轮数：1
BB :: 5 ：轮数：1
BB :: 6 ：轮数：1
BB :: 7 ：轮数：1
BB :: 8 ：轮数：1
BB :: 9 ：轮数：1
BB :: 10 ：轮数：1
CC :: 1 ：轮数：1
CC :: 2 ：轮数：1
CC :: 3 ：轮数：1
CC :: 4 ：轮数：1
...
...
CC :: 9 ：轮数：10
CC :: 10 ：轮数：10
CC :: 11 ：轮数：10
CC :: 12 ：轮数：10
CC :: 13 ：轮数：10
CC :: 14 ：轮数：10
CC :: 15 ：轮数：10

Process finished with exit code 0

三、集合的线程安全

创建集合使用string的泛型

//创建ArrayList集合
List<String> list = new ArrayList<>();

并且在集合中添加元素获取元素

for (int i = 0; i <30; i++) {

    new Thread(()->{
        //向集合添加内容
       list.add(UUID.randomUUID().toString().substring(0,8));
        //从集合获取内容
        System.out.println(list);
    },String.valueOf(i)).start();
}

查看源码，主要牵扯这个添加的方法是因为该方法在列表中是不安全的，没有synchronized声明

boolean add(E e);

运行之后报错：

Exception in thread "1" Exception in thread "3" Exception in thread "18" Exception in thread "16" Exception in thread "13" Exception in thread "15" Exception in thread "24" Exception in thread "21" Exception in thread "29" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
	at java.lang.String.valueOf(String.java:2994)
	at java.io.PrintStream.println(PrintStream.java:821)
	at com.zxl.threadTest.ThreadDemo3.lambda$main$0(ThreadDemo3.java:19)
	at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
	at java.lang.String.valueOf(String.java:2994)
	at java.io.PrintStream.println(PrintStream.java:821)
	at com.zxl.threadTest.ThreadDemo3.lambda$main$0(ThreadDemo3.java:19)
	at java.lang.Thread.run(Thread.java:748)

java.util.ConcurrentModificationException为并发修改问题
List集合的解决方案有3种：
在这里插入图片描述

1、Vector

通过list下的实现类Vector
因为在Vector下的add普遍都是线程安全
查看源代码

public synchronized boolean add(E e) {
    modCount++;
    add(e, elementData, elementCount);
    return true;
}

在改变代码时，只需要将其修改为List<String> list = new Vector<>();
但此方法用的比较少，因为在jdk 1.0的版本适用

2、Collections

Collections类中的很多方法都是static静态方法
其中有一个方法是返回指定列表支持的同步（线程安全的）列表为synchronizedList(List list)。
具体代码为

List<String> list = Collections.synchronizedList(new ArrayList<>());

此方法也比较古老，很少使用。

3、CopyOnWriteArrayList

将其代码修改为

List<String> list = new CopyOnWriteArrayList<>();

涉及的底层原理为写时复制技术：
①、读的时候并发（多个线程操作）
②、写的时候独立，先复制相同的空间到某个区域，将其写到新区域，旧新合并，并且读新区域（每次加新内容都写到新区域，覆盖合并之前的旧区域，读取新区域添加的内容）

4、CopyOnWriteArraySet

该类是HashSet的实现类
同样使用HashSet类，也会出现线程不安全。

java Set<String> set = new HashSet<>();

需要将上面的代码改为

Set<String> set = new CopyOnWriteArraySet<>();

具体操作代码为：

for (int i = 0; i <30; i++) {
    new Thread(()->{
        //向集合添加内容
        set.add(UUID.randomUUID().toString().substring(0,8));
        //从集合获取内容
        System.out.println(set);
    },String.valueOf(i)).start();
}
5、ConcurrentHashMap

HashMap不安全线程也同理Map<String,String> map = new HashMap<>();
具体实现代码是

for (int i = 0; i <30; i++) {
    String key = String.valueOf(i);
    new Thread(()->{
        //向集合添加内容
        map.put(key,UUID.randomUUID().toString().substring(0,8));
        //从集合获取内容
        System.out.println(map);
    },String.valueOf(i)).start();
}

将其代码修改为

Map<String,String> map = new ConcurrentHashMap<>();

通过这行代码可以编程线程安全。
ConcurrentHashMap类是HashMap的实现类。

exodus3
关注
专栏目录
尚硅谷—高级—JUC 高并发编程
张老师的博客
07-18 916
目录 一：JUC 概述 二：Lock 接口 三：线程间通信 四：线程间定制化通信 五：集合的线程安全 六：多线程锁 七：Callable 接口 八：JUC 强大的辅助类 九：ReentranReadWriteLock 读写锁 十：BlockingQueue 阻塞队列 十一：ThreadPool 线程池 十二：Fork / Join 分支合并框架 十三：CompletableFutrue 异步回调 一：JUC 概述 1）什么是 JUC： ...
JUC- 集合的线程安全
che_j的博客
10-28 2576
集合线程不安全及解决方案
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
自己整理的多线程JUC笔记尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
【尚硅谷】大厂必备技术之JUC并发编程——笔记总结
为了远大的理想，冲锋！
02-20 6744
【JUC并发编程01】JUC概述 关键字：进程和线程、进程和线程、wait和sleep、并发与并行、管程、用户线程和守护线程 【JUC并发编程02】Lock接口 关键字：synchronized、Lock接口、创建线程的多种方式（4种）、使用Lock实现卖票例子、synchronized和Lock两者差异 【JUC并发编程03】线程间通信 关键字：synchronized 实现案例、虚假唤醒问题、Lock 实现案例 【JUC并发编程04】线程间定制化通信（单标志法存在的问题） 关键字：线程间定制化通信
尚硅谷JUC并发编程课程笔记总结
qq_59366033的博客
08-20 1975
JUC并发编程 1、什么是juc JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 2、线程基础知识复习 1把锁：synchronized（后面细讲） 2个并： 并发：（concurrent）：是在同一实体上的多个事件，是在一台机器上“同时”处理多个任务，同一时刻，其实是只有一个事情再发生。 并行（parallel）：是在不同实体上的多个事件，是在多台处理器上同时处理多个任务，
juc并发编程学习笔记下(尚硅谷)
noob9527的博客
10-13 486
5 多线程锁 5.1锁的八个问题演示 class Phone { public static synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } public synchronized void sendEmail() throw
尚硅谷JUC笔记
qq_42449963的博客
01-12 1910
一、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
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
最新发布
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
JUC高并发编程详细讲解 狂神笔记pdf 从入门到入坟 请与狂神视频配套使用
12-17
Java并发编程是一个重要的主题，特别是在高并发应用中，如服务器端和大数据处理。JUC，全称为Java Util Concurrent，是Java平台提供的一组用于构建高效并发应用的高级API。这个包包含了各种工具类，帮助开发者处理多...
尚硅谷笔记
04-25
尚硅谷老师的se笔记总结。很详细的版本，详情视频在尚硅谷的官网中有
最全的并发编程JUC 笔记 Typora 版
10-03
JUC 笔记 基于JDK 17
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
并发编程尚硅谷笔记
weixin_47731342的博客
09-03 133
并发编程 网课链接 https://www.bilibili.com/video/BV1Kw411Z7dF?from=search&seid=17866093614757364189&spm_id_from=333.337.0.0 相关笔记链接 https://blog.csdn.net/weixin_47872288/article/details/119453092 1.JUC概述 java.util.concurrent工具包的简称 进程和线程 线程的状态 wait和sleep 并
【尚硅谷/周阳】JUC学习笔记
耿鬼不会笑的博客
04-29 3032
JUC学习笔记【尚硅谷/周阳】 本文章基于B站视频教程【juc 与 jvm 并发编程 Java 必学_阳哥- 尚硅谷】进行整理记录，仅用于个人学习，交流使用。 0.课前引入 1.进程/线程是什么? 进程： 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程： 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系
《尚硅谷高级技术之JUC高并发编程》学习笔记03—— 线程间通信
weixin_43301424的博客
11-26 488
文章目录synchronized 方案Lock 方案线程间定制化通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析。 synchronized 方案 /** * synchronized 关键字实现线程交替加减 */ public class TestSynchronized { /** * 交替加减 * @param args */ public static void main(S
JUC-01概述
Logan的博客
08-20 191
1 什么是 JUC 1.1 JUC 简介 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 进程与线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算
尚硅谷JUC极速版笔记
2301_77450803的博客
06-04 982
进程：指在系统中正在运行的一个应用程序，进程是资源分配的最小单位线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程是程序执行的最小单位Lock 实现提供比使用 synchronized 方法和语句可以获得的更广泛的锁定操作。它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象 Condition。当在不同范围内发生锁定和解锁时，必须注意确保在锁定时执行的所有代码由 try-finally 或 try-catch 保护，以确保在必要时释放锁定。
尚硅谷JUC源码学习笔记总结
木秀林的博客
10-10 1155
文章是学习 尚硅谷JUC源码讲授实战教程完整版(java juc线程精讲) 时做的笔记与总结 volatile 关键字特性 内存可见性 在同一进程的不同线程访问进程共享数据时,会将共享变量加载到当前cpu缓存中,因此不同线程对共享数据的修改不能及时在其他线程读取中体现,内存可见性就能够在写的时候强制刷新到主存中,这样就避免了其他线程的脏读 代码案例 代码本意:在线程run中 更改 状态变量之后打印,main线程中循环读状态变量,如果为真打印停止 bug原因:当对非 volatile 变量进行读写的时候，.
Java并发编程详解：JUC工具包与多线程实战
"这是一份关于JUC高并发编程的狂神笔记，旨在帮助读者从入门到精通。笔记配合狂神在B站的同步课程，提供了深入浅出的学习材料，涵盖了Java并发API的核心内容。" Java并发编程是现代软件开发中的重要技能，尤其在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

exodus3

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值