【Java基础】线程笔记——线程安全集合类

1. HashTable
2. ConcurrentHashMap
3. CopyOnWrite

HashTable

HashTable特点
1. 和HashMap都是散列表,储存键值对映射
2. 继承Dictionary、实现Serializable、Clone、Map接口
3. 初始容量（哈希表创建容量）和加载因子（哈希表中桶的数量），是影响性能的关键因素。默认加载因子0.75
4. 哈希表的方法都是同步的（线程安全）
5. 哈希表中集合元素都是无序的
6. 键值对的值都不能为null
7. 每个方法体通过synchronized修饰，保证线程安全

public class HashTableDemo {

    public static void main(String[] args) {
        Hashtable<String,Integer> ht = new Hashtable<String,Integer>();
        ht.put("one", 1);
        ht.put("two", 2);
        ht.put("three", 3);

        System.out.println("two:"+ht.get("two"));

        Hashtable<String,Integer> htClone = (Hashtable<String, Integer>) ht.clone();
        System.out.println("clone's two:"+htClone.get("two"));
    }

}

ConcurrentHashMap

1. 继承AbstractMap、实现Serializable、Map接口
2. 性能比哈希表高，允许多个修改操作并发进行，采用锁分离（代码块锁，而不是方法锁）
3. 内部使用Segment表示哈希表的不同部分（每个段就是一个小的hashtable）。同时也有自己的锁（ReentrantLock）

public static void main(String[] args) {
        ConcurrentHashMap<String,Integer> ht = new ConcurrentHashMap<String,Integer>();
        ht.put("one", 1);
        ht.put("two", 2);
        ht.put("three", 3);

        System.out.println("two:"+ht.get("two"));

        if(ht.containsKey("two")){
            ht.remove("two");
        }
        System.out.println("two:"+ht.get("two"));
}

CopyOnWriteArrayList

1. set、add、remove使用ReentrantLock中的lock加锁/unlock解锁
2. 对于读操作大于写操作的特别合适（提供高性能读取，并保证正确率)

public static void main(String[] args) {

        List<String> list = new CopyOnWriteArrayList<String>();

        for (int i = 0; i < 10; i++) {
            list.add("num"+i);
        }

        for (int i = 0; i < 10; i++) {
            System.out.println(list.get(i));
        }

        Object[] arr = list.toArray();
        System.out.println(arr.length);

}

add方法源码

CopyOnWriteArraySet

1. CopyOnWriteArraySet是在CopyOnWriteArrayList使用了Java的装饰模式。所以CopyOnWriteArrayList的东西都可以在CopyOnWriteArraySet中应用

---

CopyOnWrite机制

1. CopyOnWrite是写时复制的容器。向容器内添加元素的时候，不是在本身容器添加，而是将容器复制以后。再往里面添加元素。
   
   • 优点：可以并发的读取数据，而不需要加锁（利用读写分离思想）
2. 添加元素需要加锁，否则在多线程情况下会copy出N个复制容器

根据CopyOnWirteList源码实现CopyOnWriteMap

public class CopyOnWriteMap<K, V> implements Map<K,V>,Cloneable{
    private volatile Map<K,V> interalMap; 

    public CopyOnWriteMap(){
        interalMap = new HashMap<K,V>();
    }
}

---

    @Override
    public V put(K key, V value) {

        synchronized (this) {
            Map<K,V> newMap = new HashMap<K,V>(interalMap);
            V val = newMap.put(key, value);
            interalMap = newMap;
            return val;
        }

    }

---

    @Override
    public V get(Object key) {
        return interalMap.get(key);
    }

CopyOnWrite应用场景

用于读多写少的并发场景
比如白名单/黑名单，商品类别访问和更新等

CopyOnWriteMap注意事项

• 减少扩容开销
• 批量操作

CopyOnWrite缺点

• 内存占用（因为会涉及占用两个内存空间）
• 数据一致性（不能保证实时数据一致）

Vector

1. 继承AbstractList，实现List，支持相关CRUD操作
2. 矢量队列，通过数组保存数据
3. 实现RandomAccess接口（随机访问），可以通过元素的序号快速获取对象
4. 实现CLoneable接口
5. 实现线程安全的方法类似哈希表

public static void main(String[] args) {

        Vector<String> v = new Vector<String>();
        v.addElement("one");
        v.addElement("two");
        v.addElement("three");
        v.removeElement("two");
        if(v.contains("three")){
            Iterator<String> iter = v.iterator();
            while(iter.hasNext()){
                System.out.println(iter.next());
            }
        }

    }