线程安全集合，了解一下

傷城~ 2021-09-15 22:48 398阅读 0赞

*  Collection
    
     *  List  
        
        
         *  CopyOnWriteArrayList
         *  Vector
     *  Set  
        
        
         *  CopyOnWriteArraySet
 *  Map
    
     *  Hashtable
     *  ConcurrentMap  
        
        
         *  ConcurrentHashMap

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

# Hashtable #

的函数都是同步的，他是线程安全的  
key、value都不可以为null，映射不是有序的  
方法都有synchronized修饰

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { 
    
    
    //默认的加载因子是0.75
     public Hashtable(Map<? extends K, ? extends V> t) {
            this(Math.max(2*t.size(), 11), 0.75f);
            putAll(t);
        }

# ConcurrentHashMap #

允许多个修改操作**并发进行**，使用了锁分离技术，即代码块，不是方法锁  
使用多个锁来控制对hash表的不同部分进行的修改  
concurrentHashMap内部使用段Segment 来表示这些不懂的部分，  
每段其实就是一个小的hash table  
使用自己的ReentrantLock来实现的

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {

# CopyOnWriteArrayList #

使用了reentrantLock的lock来加锁  
是一个线程安全的List接口的实现

public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

# CopyOnWriteArraySet #

大部分调用CopyOnWriteArrayList

public class CopyOnWriteArraySet<E> extends AbstractSet<E> implements java.io.Serializable

# CopyOnWrite #

CopyOnWrite容器即写时复制容器。  
就是往一个容器添加元素的时候，不直接往当前容器添加  
而是先将当前容器进行copy出一个新的容器，然后向新的容器里添加元素  
添加完成之后  
将原容器的引用指向新的容器  
这样就可以进行并发的读写，而不需要加锁

基于读写分离的思想  
多线程添加元素的时候会copy出多个副本出来

适合于读多写少的并发场景

内存占用问题：多线程时，内存消耗太多  
数据一致性：只能保证数据的最终一致性