【JUC】003-集合类多线程不安全

向右看齐 2023-10-05 14:08 2阅读 0赞

# **目录** #

0、警醒自己

一、CopyOnWriteArrayList解决ArrayList不安全

1、概述

2、总结

解决ArrayList多线程不安全的三种方案：

CopyOnWriteArrayList比Vector强在哪里：

二、CopyOnWriteArraySet解决HashSet不安全

1、代码及注释

2、总结

解决HashSet不安全的两种解决方案：

3、HashSet底层是什么

底层是HashMap：

HashSet的add方法：

三、ConcurrentHashMap解决HashMap不安全

1、代码及注释

2、解决HashMap不安全的两种方案

3、HashMap的默认实现

--------------------

# 0、警醒自己 #

**1、学习不用心，骗人又骗己；**

**2、学习不刻苦，纸上画老虎；**

**3、学习不惜时，终得人耻笑；**

**4、学习不复习，不如不学习；**

**5、学习不休息，毁眼伤身体；**

**7、狗才等着别人喂，狼都是自己寻找食物；**

# 一、CopyOnWriteArrayList解决ArrayList不安全 #

## 1、概述 ##

（见代码和注释）

package com.zibo.unsafe;
    
    import java.util.*;
    import java.util.concurrent.CopyOnWriteArrayList;
    
    //List不安全
    public class ListTest {
        public static void main(String[] args) {
            //单线程下，这个非常安全
    //        List<String> list = Arrays.asList("1", "2", "3");
    //        list.forEach(System.out::println);
    
            //多线程测试
            //看起来没什么问题，但是报错了ConcurrentModificationException 并发修改异常
            // synchronized Vector出现于JDK1.0，是加了synchronized的，ArrayList出现于JDK1.2，没有加synchronized
            /*
             * 解决方案：
             * 1、使用List<String> list = new Vector<>();，这个答案对，但是一个很愚蠢的答案；
             * 2、让ArrayList变得安全：List<String> list = Collections.synchronizedList(new ArrayList<>());
             * 3、JUC的解决方案：List<String> list = new CopyOnWriteArrayList<>();
             */
            //CopyOnWrite，写入时复制，COW，计算机程序设计领域的一种优化策略
            //多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）
            //在写入的时候避免覆盖造成数据问题
            //c比Vector强在哪里？
            //Vector的add方法加了synchronized，执行效率低；
            //CopyOnWriteArrayList的add方法用的是lock锁
    
            //（数据库）读写分离 MyCat
    
            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();
            }
        }
    }

## 2、总结 ##

### 解决ArrayList多线程不安全的三种方案： ###

\* 1、使用List<String> list = new Vector<>();，这个答案对，但是一个很笨拙的答案；  
\* 2、让ArrayList变得安全：List<String> list = Collections.synchronizedList(new ArrayList<>());  
\* 3、JUC的解决方案：List<String> list = new CopyOnWriteArrayList<>();

### CopyOnWriteArrayList比Vector强在哪里： ###

Vector的add方法加了synchronized，执行效率低；CopyOnWriteArrayList的add方法用的是lock锁；

# 二、CopyOnWriteArraySet解决HashSet不安全 #

## 1、代码及注释 ##

package com.zibo.unsafe;
    
    import java.util.Collections;
    import java.util.HashSet;
    import java.util.Set;
    import java.util.UUID;
    import java.util.concurrent.CopyOnWriteArraySet;
    
    //Set不安全
    public class SetTest {
        public static void main(String[] args) {
    //        Set<String> set = new HashSet<>();
            //ConcurrentModificationException并发修改异常
            /*
             * 解决方案：
             * 1、Set<String> set = Collections.synchronizedSet(new HashSet<>());
             * 2、Set<String> set = new CopyOnWriteArraySet<>();
             */
            //解决方案1
    //        Set<String> set = Collections.synchronizedSet(new HashSet<>());
            //解决方案2
            Set<String> set = new CopyOnWriteArraySet<>();
            for (int i = 0; i < 30; i++) {
                new Thread(()->{
                    set.add(UUID.randomUUID().toString().substring(0,5));
                    System.out.println(set);
                },String.valueOf(i)).start();
            }
        }
    }

## 2、总结 ##

### 解决HashSet不安全的两种解决方案： ###

\* 1、Set<String> set = Collections.synchronizedSet(new HashSet<>());  
\* 2、Set<String> set = new CopyOnWriteArraySet<>();

## 3、HashSet底层是什么 ##

### 底层是HashMap： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70][]

### HashSet的add方法： ###

![20201122094908219.png][]

使用HashMap的key不重复的特性实现HashSet；

# 三、ConcurrentHashMap解决HashMap不安全 #

## 1、代码及注释 ##

package com.zibo.unsafe;
    
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.UUID;
    import java.util.concurrent.ConcurrentHashMap;
    
    //Map不安全
    public class TestMap {
        public static void main(String[] args) {
    //        Map<String, String> map = new HashMap<>();
            // 首先map是这样用的吗？工作中不用HashMap
            // 默认等价于什么？Map<String, String> map = new HashMap<>(16,0.75);loadFactor加载因子0.75，初始容量16
            //ConcurrentModificationException集合修改异常
            /*
             * 解决方案：
             * 1、Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
             * 2、Map<String, String> map = new ConcurrentHashMap<>();
             */
            //解决方案1
    //        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
            //解决方案2
            Map<String, String> map = new ConcurrentHashMap<>();
            for (int i = 0; i < 10; i++) {
                new Thread(()->{
                    map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                    System.out.println(map);
                },String.valueOf(i)).start();
            }
        }
    }

## 2、解决HashMap不安全的两种方案 ##

\* 1、Map<String, String> map = Collections.synchronizedMap(new HashMap<>());  
\* 2、Map<String, String> map = new ConcurrentHashMap<>();

## 3、HashMap的默认实现 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201122094722787.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[20201122094908219.png]: https://img-blog.csdnimg.cn/20201122094908219.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201122100538168.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70