java多线程（二） 线程安全的集合类

一般使用的Arraylist hashset hashmap 都是线程不安全的

1.java提供了 Collections 工具类将一般的 Arraylist hashset hashmap 转换成线程安全的方法

2.JUC也提供了 线程安全的集合类

 

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

public class demo50 {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();  //线程不安全
        List<Object> list2 = Collections.synchronizedList(new ArrayList<>()); //线程安全
        List<Object> list3 = new CopyOnWriteArrayList<>();  //线程安全
        Vector<Object> ve = new Vector<>();   //线程安全

        Set<Object> set = new HashSet<>(); //线程不安全
        Set<Object> set2 = Collections.synchronizedSet(new HashSet<>());
        Set<Object> set3 = new CopyOnWriteArraySet<>();

        Map<Object, Object> hm = new HashMap<>(); //线程不安全
        Map<Object, Object> hm2 = Collections.synchronizedMap(new HashMap<>());
        Map<Object, Object> hm3 = new ConcurrentHashMap<>();
    }
}

Vector<Object> objects = new Vector<>();   //线程安全   使用synchronized关键字  synchronized效率低

Vector add的源码
public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

CopyOnWriteArrayList通过 增加锁的方式保证线程安全

//CopyOnWriteArrayList  的 add源码

/** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

CopyOnWrite  写入时复制  简称 COW   计算机程序的一种优化策略
多线程 ： 在写入时 避免覆盖， 写入时先复制一份 再插入