JUC并发编程（三）-- 集合线程安全

最新推荐文章于 2024-04-09 21:38:00 发布
最新推荐文章于 2024-04-09 21:38:00 发布
阅读量458 收藏
点赞数 2
分类专栏： 多线程 java 文章标签： java 多线程 juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43827693/article/details/110313446
版权

JUC并发编程（三）-- 集合线程安全

List

一、常用的Arraylist是否为线程安全

我们平时使用的List一般都为ArrayList，那么ArrayList是否是集合安全呢？我们来用代码实际测试一下：

package com.zhan.juc.safe;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 15:06
 * 并发下ArrayList安全吗？如果不安全，有什么解决方案？
 */
public class ListDemo {

    public static void main(String[]args){
        ListDemo listDemo = new ListDemo();
        listDemo.testArrayList();
    }

    /**
     * 测试普通的ArrayList
     */
    public void testArrayList(){
        testSafe(new ArrayList<>());
    }

    /**
     * 测试当前的List集合是否线程安全
     * @param list
     */
    public void testSafe(List<String> list){
        for (int i = 0;i<10;i++){
            new Thread(()->{
                list.add(String.valueOf(System.currentTimeMillis()));
                System.out.println(list);
            }, String.valueOf(i + 1)).start();
        }
    }
}

这里的主要业务逻辑就是给list添加元素，然后起十个线程来给同一个ArrayList添加，运行结果如下：
加粗样式
我们可以看到，抛出了java.util.ConcurrentModificationException异常，这个异常就是并发修改异常，所以我们可以得出结论：普通的ArrayList不是线程安全的。

二、解决方案

那么我们如何解决，才能让ArrayList变为线程安全呢？

1）使用 Collections 工具类来创建一个线程安全的 ArrayList

上代码：

package com.zhan.juc.safe;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 15:06
 * 并发下ArrayList安全吗？如果不安全，有什么解决方案？
 */
public class ListDemo {

    public static void main(String[]args){
        ListDemo listDemo = new ListDemo();
        // 测试普通的ArrayList是否为线程安全
//        listDemo.testArrayList();

        /**
         * 解决方案
         * 1、使用 Collections 工具类创建
         */
        listDemo.testArrayListByCollections();
    }

    /**
     * 使用Collections工具类创建一个同步List
     */
    public void testArrayListByCollections(){
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        testSafe(list);
    }

    /**
     * 测试普通的ArrayList
     */
    public void testArrayList(){
        testSafe(new ArrayList<>());
    }

    /**
     * 测试当前的List集合是否线程安全
     * @param list
     */
    public void testSafe(List<String> list){
        for (int i = 0;i<10;i++){
            new Thread(()->{
                list.add(String.valueOf(System.currentTimeMillis()));
                System.out.println(list);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果如下：
在这里插入图片描述
运行成功，说明线程安全。
原因分析：
我们这里看 Collections.synchronizedList的源码：
在这里插入图片描述
这里创建了一个SynchronizedList，然后继续看SynchronizedList的源码：
在这里插入图片描述
我们发现，SynchronizedList的add() ，是一个由synchronized修饰的同步代码块，所以会线程安全。

2）使用 CopyOnWriteArrayList

上代码：

package com.zhan.juc.safe;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 15:06
 * 并发下ArrayList安全吗？如果不安全，有什么解决方案？
 */
public class ListDemo {

    public static void main(String[]args){
        ListDemo listDemo = new ListDemo();
        // 测试普通的ArrayList是否为线程安全
//        listDemo.testArrayList();

        /**
         * 解决方案
         * 1、使用 Collections 工具类创建
         * 2、使用 CopyOnWriteArrayList 来创建
         */
//        listDemo.testArrayListByCollections();

        listDemo.testArrayListByCopyOnWrite();
    }

    /**
     * <p>使用 CopyOnWriteArrayList 来创建。</p>
     * <p>CopyOnWrite -- 写入时复制 ，是 COW 思想，就是计算机程序设计领域的一种优化策略。</p>
     * <p>多个线程调用的时候，写或者添加元素时，会 copy 一份副本出来</p>
     *
     */
    public void testArrayListByCopyOnWrite(){
        List<String> list = new CopyOnWriteArrayList<>();
        testSafe(list);
    }

    /**
     * 使用Collections工具类创建一个同步List
     */
    public void testArrayListByCollections(){
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        testSafe(list);
    }

    /**
     * 测试普通的ArrayList
     */
    public void testArrayList(){
        testSafe(new ArrayList<>());
    }

    /**
     * 测试当前的List集合是否线程安全
     * @param list
     */
    public void testSafe(List<String> list){
        for (int i = 0;i<10;i++){
            new Thread(()->{
                list.add(String.valueOf(System.currentTimeMillis()));
                System.out.println(list);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果：
在这里插入图片描述
运行成功，说明线程安全。
原因分析：
我们看CopyOnWriteArrayList的源码：
在这里插入图片描述

CopyOnWriteArrayList 比较适用于 读 多 写少 的场景。
因为 CopyOnWriteArrayList 在读时是不加锁的，只有在写时才会加锁，并且copy一份副本，比较占用内存，如果是大对象的写操作，可能会造成GC问题。

CopyOnWriteArrayList也只能保证数据的最终一致性，不能保证数据的实时一致性。

Set

一、常用的HashSet是否为线程安全？

废话不多说，直接上代码测试：

package com.zhan.juc.safe;

import java.util.HashSet;
import java.util.Set;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 16:07
 * 并发下HashSet安全吗？如果不安全，有什么解决方案？
 */
public class SetDemo {

    public static void main(String[] args) {
        SetDemo setDemo = new SetDemo();
        setDemo.testHashSet();
    }

    /**
     * 测试普通的 HashSet
     */
    public void testHashSet() {
        testSafe(new HashSet<>());
    }

    /**
     * 测试当前的 set 集合是否为线程安全
     *
     * @param set
     */
    public void testSafe(Set<String> set) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                set.add(String.valueOf(System.currentTimeMillis()));
                System.out.println(set);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果如下：
在这里插入图片描述
我们发现，又看到了熟悉的java.util.ConcurrentModificationException异常，说明HashSet不是线程安全的。

二、解决方案

那么如何才能使HashSet线程安全呢？

1） 使用 Collections 创建

上代码：

package com.zhan.juc.safe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 16:07
 * 并发下HashSet安全吗？如果不安全，有什么解决方案？
 */
public class SetDemo {

    public static void main(String[] args) {
        SetDemo setDemo = new SetDemo();
        // 测试普通的HashSet是否线程安全
//        setDemo.testHashSet();

        /**
         * 解决方案
         * 1、使用 Collections 工具类创建
         * 2、使用 CopyOnWriteArraySet 来创建
         */
        setDemo.testHashSetByCollections();
    }

    /**
     * 测试普通的 HashSet
     */
    public void testHashSet() {
        testSafe(new HashSet<>());
    }

    public void testHashSetByCollections(){
        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        testSafe(set);
    }

    /**
     * 测试当前的 set 集合是否为线程安全
     *
     * @param set
     */
    public void testSafe(Set<String> set) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                set.add(String.valueOf(System.currentTimeMillis()));
                System.out.println(set);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果：
在这里插入图片描述
线程安全！

2）使用 CopyOnWriteArraySet创建

上代码：

package com.zhan.juc.safe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 16:07
 * 并发下HashSet安全吗？如果不安全，有什么解决方案？
 */
public class SetDemo {

    public static void main(String[] args) {
        SetDemo setDemo = new SetDemo();
        // 测试普通的HashSet是否线程安全
//        setDemo.testHashSet();

        /**
         * 解决方案
         * 1、使用 Collections 工具类创建
         * 2、使用 CopyOnWriteArraySet 来创建
         */
//        setDemo.testHashSetByCollections();

        setDemo.testHashSetByCopyOnWrite();
    }

    public void testHashSetByCopyOnWrite(){
        Set<String> set = new CopyOnWriteArraySet<>();
        testSafe(set);
    }

    /**
     * 测试普通的 HashSet
     */
    public void testHashSet() {
        testSafe(new HashSet<>());
    }

    public void testHashSetByCollections(){
        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        testSafe(set);
    }

    /**
     * 测试当前的 set 集合是否为线程安全
     *
     * @param set
     */
    public void testSafe(Set<String> set) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                set.add(String.valueOf(System.currentTimeMillis()));
                System.out.println(set);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果：
在这里插入图片描述
线程安全！
CopyOnWriteArraySet和上面提到的CopyOnWriteArrayList一样。

Map

一、常用的HashMap是否为线程安全？

上代码：

package com.zhan.juc.safe;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 16:31
 * 并发下HashMap安全吗？如果不安全，有什么解决方案？
 */
public class MapDemo {

    public static void main(String[] args) {
        MapDemo mapDemo = new MapDemo();

        // 测试普通的 HashMap 是否为线程安全
        mapDemo.testHashMap();
    }

    public void testHashMap() {
        testSafe(new HashMap<>());
    }

    public void testSafe(Map<String, String> map) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                map.put(String.valueOf(System.currentTimeMillis()), "");
                System.out.println(map);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果：
在这里插入图片描述
还是一样的配方，一样的味道，又出现了java.util.ConcurrentModificationException异常。

二、解决方案

1）使用 Collections 来创建同步的 HashMap

上代码：

package com.zhan.juc.safe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 16:31
 * 并发下HashMap安全吗？如果不安全，有什么解决方案？
 */
public class MapDemo {

    public static void main(String[] args) {
        MapDemo mapDemo = new MapDemo();

        // 测试普通的 HashMap 是否为线程安全
//        mapDemo.testHashMap();

        /**
         * 解决方案
         * 1、使用 Collections 工具类创建
         */
        mapDemo.testHashMapByCollections();
    }

    /**
     * 使用 Collections 来创建 同步的HashMap
     */
    public void testHashMapByCollections() {
        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        testSafe(map);
    }

    public void testHashMap() {
        testSafe(new HashMap<>());
    }

    public void testSafe(Map<String, String> map) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                map.put(String.valueOf(System.currentTimeMillis()), "");
                System.out.println(map);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果：
在这里插入图片描述
线程安全！
原因：
看源码：
在这里插入图片描述
使用Collections创建的 SynchronizedMap 的 put方法是用synchronized修饰的同步代码块，所以线程安全。

2）使用 ConcurrentHashMap 来创建

上代码：

package com.zhan.juc.safe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author Zhanzhan
 * @Date 2020/11/29 16:31
 * 并发下HashMap安全吗？如果不安全，有什么解决方案？
 */
public class MapDemo {

    public static void main(String[] args) {
        MapDemo mapDemo = new MapDemo();

        // 测试普通的 HashMap 是否为线程安全
//        mapDemo.testHashMap();

        /**
         * 解决方案
         * 1、使用 Collections 工具类创建
         * 2、使用 ConcurrentHashMap
         */
//        mapDemo.testHashMapByCollections();

        mapDemo.testHashMapByConcurrent();
    }

    /**
     * 使用ConcurrentHashMap来创建线程安全的 HashMap
     */
    public void testHashMapByConcurrent() {
        Map<String, String> map = new ConcurrentHashMap<>();
        testSafe(map);
    }

    /**
     * 使用 Collections 来创建 同步的HashMap
     */
    public void testHashMapByCollections() {
        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        testSafe(map);
    }

    public void testHashMap() {
        testSafe(new HashMap<>());
    }

    public void testSafe(Map<String, String> map) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                map.put(String.valueOf(System.currentTimeMillis()), "");
                System.out.println(map);
            }, String.valueOf(i + 1)).start();
        }
    }
}

运行结果：
在这里插入图片描述
线程安全！

书生灬今天不吃饭
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java 多线程与并发(13-26)-JUC集合- ConcurrentHashMap详解.pdf
07-26
Java 多线程与并发(13_26)-JUC集合_ ConcurrentHashMap详解
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
JUC集合类
复制乔布斯
04-11 1103
CopyOnWriteArrayList 是 Java 并发集合框架中的一种线程安全的列表实现，它在读多写少的场景下性能较好。下面对 CopyOnWriteArrayList 进行详解。CopyOnWriteArrayList 是一个线程安全的动态数组，它的特点是在进行写操作（添加、删除、修改元素）时，会创建一个新的数组来进行操作，从而实现了多线程之间的隔离，避免了读写冲突，因此不需要显式的加锁。线程安全。
JUC包下的常用并发类
最新发布
aa469779409的专栏
04-09 846
Semaphore（信号量）是一种用于多线程编程的同步工具，用于控制同时访问某个资源的线程数量，即一个资源最多只能根据所设置的访问线程数量的线程数访问吗，多余的线程会被阻塞。集，即类似多玩家对战类的游戏，每个玩家加载游戏的速度不同，先加载好的玩家（线程）会被阻塞，只有当所有玩家的游戏都准备完毕之后，才会释放（将阻塞的方法立即返回）。：线程在获取锁时，不按照等待的先后顺序获取锁，而是随机获取锁，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。
JUC并发编程（13）——线程安全集合类
qq_51114283的博客
10-08 477
一、概述 线程安全集合类可以分为三大类 ： ① 遗留的安全集合如Hashtable，Vector。 ② 使用Collections装饰的线程安全类如Collections.synchronizedList、Collections.synchronizedMap等。 ③ JUC包下的线程安全集合如Blocking类、CopyOnWrite类、Concurrent类等。 ①是直接在方法上加上了synchronized锁，②是方法内部加上了synchronized锁。这里主要介绍的是JUC包下的线程安全集合类
JUC基础（四）—— 并发集合
战斧的博客
04-28 420
我们在JUC的开篇讲过，juc包主要包含以下部分：线程池 并发集合 同步器 原子变量 锁 并发工具类那么本次我们就来讲一讲并发集合
【JUC基础】11. 并发下的集合类
有一只柴犬的专栏
05-28 920
我们直到ArrayList，HashMap等是线程不安全的容器。但是我们通常会频繁的在JUC中使用集合类，那么应该如何确保线程安全？
JUC-线程安全集合类
微信公众号：饺子泡牛奶
11-05 872
一、概述 二、ConcurrentHashMap 2.1 并发问题 2.2 重要属性和内部类 2.3 重要方法 2.4 构造器 2.5 get 流程 2.6 put 流程 2.7 size 计算流程 2.8 对比 JDK 7 的 ConcurrentHashMap 有什么区别？ 三、LinkedBlockingQueue 3.1 入队出队 3.2 加锁分析
JUC编程笔记-zfs.pdf
04-11
本笔记主要讲解了 Java 中的并发编程相关知识，包括进程和线程、并发和并行、异步和同步等概念的解释和区别。 进程与线程 进程是指令和数据的集合，程序被加载到内存中，CPU 执行指令，磁盘和网络等设备参与进程的...
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
JUC代码收集，java高并发多线程学习
03-31
Java并发编程是Java开发中的重要领域，而Java.util.concurrent（JUC）工具包则是Java并发编程的核心组件。这个集合提供了一系列高效、线程安全的类和接口，用于简化多线程环境下的编程任务。本资源"JUC代码收集，...
JUC——并发集合类
weixin_34344677的博客
05-21 372
如果要进行多个数据的保存，无疑首选类集（List、Set、Queue、Map），在类集的学习的时候也知道一个概念：许多集合的子类都具有同步与异步的差别，但是如果真的要在多线程之中去使用这些类，是否真的可以用呢？ 范例：观察一下类集的问题： package so.strong.mall.concurrent; import java.util.ArrayList; import java...
JUC之线程安全的集合
weixin_38568503的博客
03-04 2403
当一边往集合添加数据，一边取数据的时候，会出现并发修改异常； vector:所有方法都是sync修饰的 方法二： 方法三：工作中常用：
JUC-并发集合类
isaiah的专栏
08-19 846
在大家学习Java基础时都知道，ArrayList、LinkedList、HashMap、HashSet等常用的容器类都是线程不安全的，如果有多个线程访问它们时将会出现意外结果，下边我们讲解如果使用线程安全的集合类。 使用java.util包下线程安全的集合类 使用Collections工具类将非线程安全的集合包装成线程安全的集合 使用juc中的并发集合类 Vector与Hashtable ...
juc并发集合类
weixin_43766256的博客
05-03 262
集合总览 Queue 接口 ConcurrentLinkedQueue 实现类 BlockingQueue 接口 ArrayBlockingQueue实现类 DelayQueue 实现类 PriorityBlockingQueue 实现类 SynchronousQueue实现类 Deque接口 ArrayDueue实现类 LinkedList实现类 BlockingDeque 接口 Linke...
juc并发集合类_并发集合类
cusi77914的博客
06-30 588
出现在Java类库中的第一个关联集合类是Hashtable ，它是JDK 1.0的一部分。 Hashtable提供了易于使用，线程安全的关联映射功能，并且肯定很方便。 但是，线程安全是要付出代价的Hashtable所有方法都是同步的。 当时，无竞争的同步具有可衡量的性能成本。 Hashtable的后继者HashMap出现在JDK 1.2中的Collections框架中，它通过提供未同步的基类和...
JUC常见类以及线程安全的集合类
weixin_58850105的博客
04-17 1366
这是关于线程的最后一更啦~~~ 目录 1.JUC常见类 1.1Callable接口 1.2ReentrantLock 1.3信号量 Semaphore 1.4CountDownLatch 2.线程安全的集合类 2.1多线程环境使用 ArrayList 2.2多线程环境使用队列 2.3多线程环境使用哈希表 2.3.1Hashtable 2.3.2ConcurrentHashMap 1.JUC常见类 JUC的全称：java.util.concurrent（concurrent指..
JUC中的锁、信号量、并发集合
weixin_53455615的博客
08-27 355
如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用， 获取不到锁的线程加入到队列中。suspend()和resume()是synchronized中的暂停和恢复。对该同步状态进行原子操作实现对其值的修改，当state大于0的时候表示锁被占用，如果state等于0时表示没有占用锁。：新添加的线程先尝试获取获取资源，若获取到之间执行此线程，若没有获取到就添加到队列中去排队。1. ReentrantLock(): 创建非公平锁的重入锁。.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值