并发下集合不安全

末蓝、 2022-12-28 07:39 75阅读 0赞

### 文章目录 ###

*   *  集合类不安全
     *   *  List不安全
         *  Set不安全
         *  Map不安全

## 集合类不安全 ##

### List不安全 ###

public class ListTest { 
        public static void main(String[] args) { 
            List<String> list = new ArrayList<>();
    
            for (int i = 1; i <= 100; i++) { 
                new Thread(()->{ 
                    list.add(UUID.randomUUID().toString().substring(0,5));
                    System.out.println(list);
                },String.valueOf(i)).start();
            }
        }
    }

会抛出异常`java.util.ConcurrentModificationException`并发修改异常！

**并发下ArrayList不安全，它的add方法不是原子操作。**

解决方案：

> 1、List list = new Vector<>();
> 
> 底层加了synchronized锁。
> 
> 2、List list = Collections.sychronizedList(new ArrayList<>());
> 
> 也是加sychronized锁
> 
> 3、List list = new CopyOnWriteArrayList<>();
> 
> 使用 transient volatile 关键字修饰数组，保证线程安全。
> 
> CopyOnWrite 写入时复制 简称：COW 是计算机程序设计领域的一种优化策略；
> 
> 在写入的时候避免覆盖，造成数据问题。
> 
> CopyOnWrieArrayList() 比 Vector() 效率高，使用sychronized修饰后效率会比较低。

public class ListTest { 
        public static void main(String[] args) { 
            List<String> list = new CopyOnWriteArrayList<>();
    
            for (int i = 1; i <= 100; i++) { 
                new Thread(() -> { 
                    list.add(UUID.randomUUID().toString().substring(0, 5));
                    System.out.println(list);
                }, String.valueOf(i)).start();
            }
        }
    }

### Set不安全 ###

public class SetTest { 
        public static void main(String[] args) { 
            Set<String> set = new HashSet<>();
            for (int i = 1; i <= 100; 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 方法。
> 
> Set set = Collections.synchronizedSet(new HashSet<>());
> 
> 2、JUC包下的CopyOnWriteArraySet
> 
> Set set = new CopyOnWriteArraySet<>();

public class SetTest { 
        public static void main(String[] args) { 
            Set<String> set = new CopyOnWriteArraySet<>();
            for (int i = 1; i <= 100; i++) { 
                new Thread(()->{ 
                    set.add(UUID.randomUUID().toString().substring(0,5));
                    System.out.println(set);
                },String.valueOf(i)).start();
            }
        }
    }

**HashSet底层**

// HashSet底层为HashMap
    public HashSet(){ 
        map = new HashMap<>();
    }
    
    // HashSet 的 add 方法本质就是 map 的 put 方法，key 是无法重复的！
    public boolean add(E e){ 
        return map.put(E, PRESENT)==null;
    }
    
    private static final Object PRESENT = new Object(); // 不变的常量！

### Map不安全 ###

public class MapTest { 
        public static void main(String[] args) { 
            Map<String,String> map = new HashMap<>();
            for (int i = 1; i <= 100; i++) { 
                new Thread(()->{ 
                    map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                    System.out.println(map);
                },String.valueOf(i)).start();
            }
        }
    }

**HashMap底层**

> 底层JDK1.7是通过数据+链表，JDK1.8是通过数组+链表+红黑树组成。所有的数据都是通过一个Node节点进行封装，其中Node节点中封装了hash值，key，value，和next指针。不同的key计算出来的hash值可能相同，解决冲突是通过拉链法（链表和红黑树）进行处理。正式因为这种存储形式，所以HashMap的存储顺序是无序的。
> 
> **加载机制**
> 
> 懒加载机制，在put值的时候会判断数组是否为空，如果是就初始化数组，而不是new的时候就初始化。
> 
> **默认初始化容量：16**
> 
> **扩容机制**
> 
> **默认加载因子：0.75f**，扩容机制是根据扩容因子来扩容的；例如：当容量的使用量达到总容量的0.75时，就会触发扩容，举例就是说，当总容量是16时，使用量达到12，就会触发扩容机制。
> 
> 扩容的新空间大小是旧空间的2倍。（`newThr = oldThr << 1;`）
> 
> 扩容操作最消耗性能的地方就是，原数组中的数据要重新存放，也就是resize()，即重新计算索引，重新分配。
> 
> **处理冲突**
> 
> 当我们put一个值的时候，通过key来计算出hash值，计算出来的hash值作为数组的索引，Node节点中封装了hash值，key，value和next。
> 
> 当链表的长度小于8的时候，处理冲突的方式是链表。大于等于8的时候，就会触发红黑树方式存储。
> 
> 当元素个数小于等于6的时候，会触发红黑树转化为链表的形式，为什么不是小于等于7，是因为给一个过度，也就是防止添加一个刚好为8，删除一个刚好为7，这样来回转化。

解决方式：

> 1、使用HashTable，底层加了synchronized锁
> 
> Map<String,String> map = new Hashtable<>();
> 
> 2、使用JUC包下的ConcurrentHashMap
> 
> Map<String,String> map = new ConcurrentHashMap<>();

public class MapTest { 
        public static void main(String[] args) { 
            Map<String,String> map = new ConcurrentHashMap<>();
            for (int i = 1; i <= 100; i++) { 
                new Thread(()->{ 
                    map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                    System.out.println(map);
                },String.valueOf(i)).start();
            }
        }
    }