Java多線程高并發(fā)中解決ArrayList與HashSet和HashMap不安全的方案

更新時間：2021年11月16日 11:06:07 作者：張起靈-小哥

ArrayList實現(xiàn)了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步，HashMap和Hashtable類似，不同之處在于HashMap是非同步的，并且允許null，關于HashSet有一件事應該牢記，即就條目數和容量之和來講，迭代是線性的，接下來讓我們詳細來了解吧

1.ArrayList的線程不安全解決方案

將main方法的第一行注釋打開，多執(zhí)行幾次，會看到如下圖這樣的異常信息：👇👇👇

這是一個并發(fā)修改異常，首先ArrayList肯定是線程不安全的，產生這個異常的原因就是可能第一個線程剛進入 ArrayList 集合中要進行 add 操作時，另外一個線程此時也進來進行 add 操作，而第三個線程又進來進行 get 操作，導致讀寫沒辦法進行同步了，最終打印結果的時候就炸了。

解決方案看代碼中的剩下幾行注釋。

package test.notsafe;
 
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
 
/**
 * 演示ArrayList的線程不安全問題及解決方案
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //List<String> list = new ArrayList<>();
 
        //解決方法1：使用Vector
        //List<String> list = new Vector<>();
 
        //解決方法2：Collections
        //List<String> list = Collections.synchronizedList(new ArrayList<>());
 
        //解決方法3：CopyOnWriteArrayList
        List<String> list = new CopyOnWriteArrayList<>();
 
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

關于 CopyOnWriteArrayList 解決線程不安全問題的簡單解釋：就看源碼中的 add(E e) 這個方法：

    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();
        }
    }

這個 CopyOnWriteArrayList 在進行 add 添加操作之前，先進行 lock 上鎖，然后通過 getArray() 獲取到原 ArrayList 集合容器，之后調用 Arrays.copyOf 方法將原容器拷貝出一個新容器，因為要添加（長度自然也要 +1），之后向這個新容器中添加元素，添加完成之后，調用 setArray 方法將原容器的引用指向了這個新的容器。那么這樣做的好處就是：添加元素在新容器中，原容器該是啥樣還是啥樣，其他線程要get讀取元素就還從原容器中讀（即多個線程可以進行并發(fā)讀）；而其他線程要 add 添加，要等待其他線程完成之后，將原容器的引用指向新容器就可以了。

CopyOnWrite 容器在面對讀和寫的時候是兩個不同的容器，也是用到了讀寫分離的思想。

2.HashSet的線程不安全解決方案

這里如果是 new HashSet 了話，仍然可能出現(xiàn)向上面 ArrayList 一樣的并發(fā)修改異常。解決方案看代碼中的注釋。

package test.notsafe;
 
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
 
/**
 * 演示HashSet的線程不安全問題及解決方案
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //Set<String> set = new HashSet<>();
 
        //解決方法1：Collections
        //Set<String> set = Collections.synchronizedSet(new HashSet<>());
 
        //解決方法2：CopyOnWriteArraySet
        Set<String> set = new CopyOnWriteArraySet<>();
 
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

3.HashMap的線程不安全解決方案

package test.notsafe;
 
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * 演示HashMap的線程不安全問題及解決方案
 */
public class ThreadDemo4 {
    public static void main(String[] args) {
        //Map<String,Object> map = new HashMap<>();
 
        //解決方法1：Collections
        //Map<String,Object> map = Collections.synchronizedMap(new HashMap<>());
 
        //解決方法2：ConcurrentHashMap
        Map<String,Object> map = new ConcurrentHashMap<>();
 
        for (int i = 0; i < 10; i++) {
            String key = String.valueOf(i);
            new Thread(() -> {
                map.put(key,UUID.randomUUID().toString().substring(0,8));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

到此這篇關于Java多線程高并發(fā)中解決ArrayList與HashSet和HashMap不安全的方案的文章就介紹到這了,更多相關Java 多線程高并發(fā)內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: