集合类不安全问题解决方案

最新推荐文章于 2022-03-30 13:48:31 发布
最新推荐文章于 2022-03-30 13:48:31 发布
阅读量203 收藏 1
点赞数 1
分类专栏： JUC并发编程 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46027706/article/details/112983315
版权

一、List

我们来看一下ArrayList的线程安全吗？

package com.yy;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListTest {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        for (int i = 0; i < 30; i++) {

            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }

}

结果给我们抛出了一个异常：java.util.ConcurrentModificationException ：并发修改异常。
说明：

Arraylist在并发情况下是不安全的，那么我们如何去解决这个不安全呢？
看一下源码：
在这里插入图片描述
我们常见的解决方案是 Synchronized关键字去做线程同步。

以下会给出三种解决方案：

1.Vector。 List < String > list = new Vector<>();

看一下Vector操作集合的方法源码，均使用了Synchronized的关键字，所以线程是安全的。
以添加为例：

在这里插入图片描述
验证代码：通过多线程的方式验证并发问题：

package com.yy;

import java.util.*;

public class ListTest {
    public static void main(String[] args) {
//        List<Object> list = Arrays.asList("a","b","c");
        System.out.println(list);
        List<String> list = new Vector<>();
        for (int i = 0; i < 10; i++) {

            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }

}

运行结果：

在这里插入图片描述

2.通过Collections工具类来实现线程安全问题

package com.yy;

import java.util.*;

public class ListTest {
    public static void main(String[] args) {
//        List<Object> list = Arrays.asList("a","b","c");
        System.out.println(list);
//        List<String> list = new Vector<>();
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 10; i++) {

            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }

}

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

3.通过JUC并发CopyOnWriteArrayList来解决不安全问题

package com.yy;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListTest {
    public static void main(String[] args) {
//        List<Object> list = Arrays.asList("a","b","c");
        System.out.println(list);
//        List<String> list = new Vector<>();
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {

            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }

}

结果线程安全
在这里插入图片描述
CopyOnWrite 写入时复制(COW),是计算机的一种优化策略。

那么CopyOnWrite比Vector好在哪？
我们可以去看下源码：
Vector： 使用了Synchronized 而 CopyOnWrite 使用的是Lock锁，在效率方面CopyOnWrite的效率要比Vector高。这个可以去写一个代码测试下运行时间得到。
在这里插入图片描述

二、Set

同样的我们还可以去解决Set集合的不安全问题

package com.yy;

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

public class SetTest {

    public static void main(String[] args) {

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

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }


    }
}

结果抛出了一个问题：java.util.ConcurrentModificationException 依然是并发修改错误。
接下来我们来解决这个问题

  1. Collections的synchronizedSet方法 实现 同步
package com.yy;

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

public class SetTest {

    public static void main(String[] args) {

      //  Set<String> set = new HashSet<>();
        Set<String> set = Collections.synchronizedSet(new HashSet<>());

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }


    }
}

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

2.使用JUC的CopyOnWrite实现线程安全

package com.yy;

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

public class SetTest {

    public static void main(String[] args) {

      //  Set<String> set = new HashSet<>();
      //  Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<Object> set = new CopyOnWriteArraySet<>();

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }


    }
}

结果：
在这里插入图片描述
那么HashSet的底层是什么？
我们看一下源码：
在这里插入图片描述
其实HashSet的本质就是HashMap，HashSet的元素是无序不能重复的，使用的Map的key
在这里插入图片描述

三、HashMap

在多线程下使用HashMap会造成并发问题

package com.yy;

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

public class MapTest {

    public static void main(String[] args) {

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

        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }

    }
}

结果抛出了 并发修改异常在这里插入图片描述

现在去解决这个问题

1.使用Collections.synchronizedMap()方法实现线程同步

package com.yy;

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

public class MapTest {

    public static void main(String[] args) {

 //       Map<String, String> map = new HashMap<>();
        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());

        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }

    }
}

结果：
在这里插入图片描述

2.JUC并发变成为我们提供了一种解决方案
并发包下的
在这里插入图片描述

package com.yy;

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

public class MapTest {

    public static void main(String[] args) {

 //       Map<String, String> map = new HashMap<>();
  //      Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        Map<String, String> map = new ConcurrentHashMap<>();

        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }

    }
}

结果：测试成功。

以上就是解决集合不安全的方案，我们在初学的时候往往会忽略多线程的情况，而在实际的开发中我们必须是要解决并发问题的，另外通过对集合不安全的问题的解决的同时需要去了解集合，这时重点问题。
InsistCode
关注
专栏目录
Java面试笔记：Java线程安全的集合类有哪些？线程不安全的集合类有哪些？ArrayList为什么会发生并发修改异常?
蓝多多的小仓库
11-10 1478
Java面试笔记：Java线程安全的集合类有哪些？线程不安全的集合类有哪些？ArrayList为什么会发生并发修改异常?
Java 集合中的类关于线程安全
08-31
在Java中，集合类分为线程安全和非线程安全两类。 线程安全的集合类： 1. Vector：类似于ArrayList，但每个操作都是线程安全的，因为内部使用了`synchronized`关键字来保证同步。然而，由于过度的同步，它的性能...
集合类不安全问题
liaozhongmin_net
09-30 154
一.集合类不安全---并发修改异常(java.util.ConcurrentModificationException) 二.集合类不安全写时复制 代码示例： import java.util.ArrayList; import java.util.List; import java.util.UUID; public class ContainerNoSafeDemo { public static void main(String[] args) { List&lt
ArrayList线程不安全和解决办法
Funny_Ma的博客
10-18 402
ArrayList线程不安全的实例代码 package com.jian8.juc.collection; import java.util.ArrayList; import java.util.List; import java.util.UUID; /** * 集合类不安全问题 * ArrayList */ public class ContainerNotSafeDemo { ...
七、集合不安全
小薛博客助力人人成为架构师
11-15 327
七、集合不安全1、线程不安全错误2、List不安全1、 解决方案1、Vector2、Collections3、写时复制(JUC)4、CopyOnWrite理论3、Set不安全4、Map不安全下一章：JUC强大的辅助类更多内容： 1、线程不安全错误 java.util.ConcurrentModificationException ArrayList在迭代的时候如果同时对其进行修改就会 抛出java.util.ConcurrentModificationException异常 并发修改异常 2、List不
集合类不安全的解决方法
wyljdc的博客
03-22 120
集合类不安全之list，set与map ArrayList 线程不安全，为什么不安全呢？看下面截图 看add源码，为了保证并发性和效率，add方法没有加锁（synchronized） 为了解决arrayList线程不安全这个问题，我们有以下三种解决方法： 1.继承vector方法（vector的add方法有锁） 2.collections是collection集合类的工具类（利用工具类来找个线程安全的辅助类继承），我们可以看到collections里面还有相似的synchronizedMap和syn
集合不安全问题
nmgyangguangyuan的博客
06-18 249
ArrayList 问题 线程不安全,报错:java.util.ConcurrentModificationException package top.ygy.thread; import java.util.ArrayList; import java.util.List; import java.util.UUID; /** * @Description: TODO(集合类不安全问题) ...
关于如何解决HashMap线程安全问题的介绍
08-22
理解这个问题并找到解决方案是每个Java开发者必须掌握的知识。 HashMap线程不安全的原因主要在于以下几个方面： 1. 多线程环境下并发修改：在多线程环境下，如果多个线程同时对HashMap进行读写操作，可能会导致...
jdk中线程安全的集合类.docx
05-28
非线程安全的数据结构如`HashMap`在高并发场景下可能会出现数据不一致等问题，这促使了线程安全的集合类如`ConcurrentHashMap`、`ConcurrentSkipListMap`等的诞生和发展。本文将重点介绍`ConcurrentHashMap`的工作...
Java软件开发实战 Java基础与案例开发详解 12-5 集合类的同步问题 共8页.pdf
最新发布
07-07
本章节详细介绍了Java集合类在多线程环境下可能遇到的同步问题，并提出了三种常用的解决方法。开发者可以根据实际情况选择最合适的方案来确保代码的正确性和高性能。随着Java版本的不断更新，更多高效且易于使用的...
集合类不安全
辰小诺
08-19 149
集合类不安全 /** * 集合类不安全问题 * ArrayList * HasHsET * @author chenxiaonuo * @date 2019-08-12 11:00 */ public class ContainerNotSafeDemo { public static void main(String[] args) { Map<S...
集合类不安全（unSale）
weixin_45723046的博客
03-30 404
集合类不安全（unSale） 1：List不安全 package com.baidu.unSale; import java.util.*; import java.util.concurrent.CopyOnWriteArrayList; /* java.util.ConcurrentModificationException 并发修改异常 */ public class ListTest { public static void main(String[] args) {
集合不安全
qq_40826814的博客
04-21 113
1）List 不安全 //java.util.ConcurrentModificationException 并发修改异常！ public class ListTest { public static void main(String[] args) { List<Object> arrayList = new ArrayList<>(); for(int i=1;i<=10;i++){ new Threa
不安全的集合类list以及解决方法
qq_17690301的博客
09-10 471
java提供的集合类list为不安全类 不安全类是什么意思？ 不安全类指的是在多线程并发的时候不能保证数据正确性的类，通常是由于这些类并没有加锁造成的。 为什么不设计为加锁的呢？ 其实，在list之前有一个集合类vector，它是内部加锁的，它是一个线程安全类，但为何我们却不优先去使用它呢，我们要知道，加锁可以保证数据的正确性，但却降低了并发效率！ 我们要怎么做才能保证数据的正确性呢？ 使用vector替代list(并发效率降低) 使用Collections.synchronizedList(list)包
JUC并发编程（三) : 不安全的集合类
Hi_alan的博客
03-07 405
不安全的集合类 在并发环境下，我们经常使用的集合类（List、Map、Set）其实都是不安全的！ List List在单线程的情况下是安全的，但是多线程的情况下是不安全的，我们来看两段代码： 单线程 public class UnsafeList1 { public static void main(String[] args) { List<String> l...
集合类不安全的问题
qq_28772075的博客
08-02 423
1. ArrayList 1.1 介绍 1.2 ArrayList线程不安全的DEMO 1.2.1 故障现象 1.2.2 导致原因 1.2.3 解决方案 1.2.4 优化建议JUC中CopyOnWriteArrayList解决问题的原理 2 Set 2.1 HashSet线程不安全 2.2 CopyOnWriteArraySet介绍 2.1.1 CopyOnWriteArraySet源码解析
集合的线程不安全问题及相对应的线程安全解决方法
qq_38307826的博客
06-29 333
java的util包中提供的集合List、Map、Set是线程不安全的，当在其迭代的时候同时对其进行修改就会抛出java.util.ConcurrentModificationException异常并发修改异常 例子如下： public class NoSafeArrayList { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (int i = 0;
Java集合类不安全问题（HaspMap不安全）
HapSlience
06-17 750
Java 集合类不安全问题ArrayList为什么ArrayList 不安全怎么解决ArrayList 不安全问题HashSet不安全问题HashMap什么时候HashMap是不安全的？怎么解决HashMap不安全问题 Java中的一些集合类：例如ArrayList、HashSet、HashMap 在并发条件下都是不安全的。一般情况下报的错误是：“Concurrent Modification E...
Java集合线程安全：从问题到解决方案
当需要在多线程环境下使用线程不安全的集合时，有以下几种解决方案： 1. 使用线程安全的集合类，如`Vector`和`HashTable`。然而，由于它们的同步机制导致的性能问题，一般不推荐在性能敏感的场景下使用。 2. 使用`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值