集合之线程安全问题(ArrayList,Set,Map)解决方案

一:ArratList 线程不安全：直接看代码演示：

导致原因:(集合不安全的原因)：并发争抢修改，一个人正在写，另一个人过来抢着写，所以导致结果不一致

public class ArrayList {
    public static void main(String[] args) {
        List<String> list = new java.util.ArrayList<>();

        for (int i = 1; i <= 20; i++)
        {
            // 多线程
     new Thread(() ->{
         list.add(UUID.randomUUID().toString().substring(0,9));
         System.out.println(list);
     },String.valueOf(i)).start();
        }
    }
}

异常: java util ConcurrentModificationException 并发修改的异常

// 解决方案:
1可以使用vator解决因为vactor是线程安全的，底层使用synchronized修饰的，部件与，因为他的性能太低了

 

2:可以使用collections来解决，他可以通过Collections中的中创建一个线程安全的arrayList

public class ArrayList {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new java.util.ArrayList<>());
        for (int i = 1; i <= 20; i++)
        {
            // 多线程
     new Thread(() ->{
         list.add(UUID.randomUUID().toString().substring(0,9));
         System.out.println(list);
     },String.valueOf(i)).start();
        }
    }
}
用Collectons创建的ArrayList 就是线程安全的

3:CopyOnWriteArrarlist 解决集合安全问题。

为什么CopyOnWriteArralist可以解决呢:

1：底层源码中用了valatile 修饰和锁机制就一个不是很恰的例子:比如现在班级签到，没有签到的同学请来签到，第一个人(李四)他签到以后，在把新的签到名单交上去，下一个人在继续来签到，签到的刚才那个人提交的新名单，而且每次致多出一个位置，等提交以后没在把所释放没留个下个人进来签到

/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return {@code true} (as specified by {@link Collection#add})
 */
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();
    }
}

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

二: HashSet 线程不安全的原因

1:验证: 也会报ConcurrentModificationException 同样解决方案同理 可以使用Collections解决Set<String> set = Collections.synchronizedSet(new HashSet<>());

public class ArrayList {
    public static void main(String[] args) {
//        List<String> list = new CopyOnWriteArrayList<>();
    Set<String> set = new HashSet();
        for (int i = 1; i <= 20; i++)
        {
            // 多线程
     new Thread(() ->{
         set.add(UUID.randomUUID().toString().substring(0,9));
         System.out.println(set);
     },String.valueOf(i)).start();
        }
    }
}

2: CopyOnWritreSet 解决: 源码 用的也是CopyOnWriteArrayList来解决的

/**
 * Creates an empty set.
 */
public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList<E>();
}

    private boolean addIfAbsent(E e, Object[] snapshot) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] current = getArray();
            int len = current.length;
            if (snapshot != current) {
                // Optimize for lost race to another addXXX operation
                int common = Math.min(snapshot.length, len);
                for (int i = 0; i < common; i++)
                    if (current[i] != snapshot[i] && eq(e, current[i]))
                        return false;
                if (indexOf(e, current, common, len) >= 0)
                        return false;
            }
            Object[] newElements = Arrays.copyOf(current, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

HashSet 底层就是HashMap原理，但是HashSet用的ADD方法并且只需要加一个值但是源码底层写的是HashMap的Map 方法key 就等add的那个值，value 是一个叫new Object()常量对象

Map线程安全不安全的问题: