Java如何解決ArrayList的并發(fā)問題

更新時間：2025年04月30日 09:44:30 作者：Roc.Chang

這篇文章主要介紹了Java如何解決ArrayList的并發(fā)問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

1. 場景復現(xiàn)

1.1 數(shù)據(jù)不一致問題示例代碼

import java.util.ArrayList;
import java.util.List;

public class ArrayListConcurrencyExample {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();

        // 創(chuàng)建并啟動多個線程，同時向ArrayList添加元素
        Runnable addTask = () -> {
            for (int i = 0; i < 1000; i++) {
                arrayList.add(i);
            }
        };

        Thread thread1 = new Thread(addTask);
        Thread thread2 = new Thread(addTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 輸出ArrayList的大小，不一定是預期的 2000 
        System.out.println("Size of arrayList: " + arrayList.size());
    }
}

1.2 ConcurrentModificationException 問題示例代碼

ConcurrentModificationException通常會在迭代ArrayList（或其他集合）的同時對其進行結構性修改時拋出。

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

public class ConcurrentModificationExample {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();

        arrayList.add("Item1");
        arrayList.add("Item2");
        arrayList.add("Item3");

        // 獲取迭代器
        Iterator<String> iterator = arrayList.iterator();

        // 開始迭代
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);

            // 在迭代過程中嘗試修改ArrayList的結構，會引發(fā)ConcurrentModificationException
            if (item.equals("Item2")) {
                arrayList.remove(item);
            }
        }
    }
}

當處理ArrayList的并發(fā)問題時，不同的方法有不同的細節(jié)和適用場景。以下是對每種方法的詳細解釋：

2. 解決并發(fā)的三種方法

2.1 使用 Collections.synchronizedList

使用 Collections.synchronizedList 創(chuàng)建線程安全的ArrayList這是一種簡單的方式來使ArrayList線程安全。

它實際上是包裝了一個原始的ArrayList，并在每個方法上添加synchronized關鍵字來確保每個方法在同一時間只能由一個線程訪問。

List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());

這種方法適用于那些多數(shù)情況下是讀操作，但偶爾需要寫操作的情況。

請注意，盡管每個方法都是線程安全的，但多個操作之間沒有原子性保證，因此還需要其他方式來確保多個操作的一致性。

例如下面的代碼就會出現(xiàn)并發(fā)問題：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SynchronizedListExample {
    public static void main(String[] args) {
        List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());

        Runnable addAndRemoveTask = () -> {
            for (int i = 0; i < 1000; i++) {
                synchronizedList.add(i);
                synchronizedList.remove(synchronizedList.size() - 1);
            }
        };

        Thread thread1 = new Thread(addAndRemoveTask);
        Thread thread2 = new Thread(addAndRemoveTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Size of synchronizedList: " + synchronizedList.size());
    }
}

在這個示例中，兩個線程同時執(zhí)行add和remove操作。雖然每個操作本身是線程安全的，但它們的組合會導致競態(tài)條件，多次運行后，會出現(xiàn)下面的情況：

最終列表的大小可能不是預期的 2000。

由于兩個線程同時進行remove操作，可能導致其中一個線程試圖刪除一個元素，但在另一個線程之前已經刪除了，導致IndexOutOfBoundsException異?；蚱渌灰恢碌慕Y果

Exception in thread "Thread-0" java.lang.IndexOutOfBoundsException: Index 1 out of bounds for length 1
   at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:64)
   at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:70)
   at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:248)
   at java.base/java.util.Objects.checkIndex(Objects.java:372)
   at java.base/java.util.ArrayList.remove(ArrayList.java:536)
   at java.base/java.util.Collections$SynchronizedList.remove(Collections.java:2435)
   at com.test.testlist.SynchronizedListExample.lambda$main$0(SynchronizedListExample.java:14)
   at java.base/java.lang.Thread.run(Thread.java:834)
Size of synchronizedList: 1

這突顯了Collections.synchronizedList在某些情況下可能無法提供足夠的并發(fā)保護，因此需要額外的同步措施或選擇更適合并發(fā)操作的數(shù)據(jù)結構。

2.2 使用 CopyOnWriteArrayList（推薦使用）

CopyOnWriteArrayList是一種并發(fā)集合，它通過在寫操作時創(chuàng)建一個新的副本來解決并發(fā)問題。

這意味著讀操作不會受到寫操作的影響，而且不會拋出ConcurrentModificationException異常。

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

這種方法適用于讀操作頻繁，寫操作較少的情況，因為寫操作會比較昂貴。但它非常適用于多線程下的讀操作，因為它不需要額外的同步。

2.3 使用顯式的同步控制

這種方法需要在需要修改ArrayList的地方使用synchronized塊或鎖來確保線程安全。

這是一種更精細的控制方法，適用于需要更多控制和協(xié)同操作的場景。

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

// 在需要修改list的地方加鎖
synchronized (list) {
    list.add("item");
}

這種方式要求手動管理鎖，通過加鎖確保在修改ArrayList時進行同步，以防止多個線程同時訪問它。

總結

一般在日常編碼中，直接使用 CopyOnWriteArrayList 就能滿足很多場景；
但是由于每次進行寫操作時，都需要復制整個列表，這會導致寫操作的性能較低，尤其在列表很大時。因此，CopyOnWriteArrayList 適用于讀操作頻繁、寫操作較少的場景。
使用 CopyOnWriteArrayList 時候，應該避免在迭代過程中修改列表；
CopyOnWriteArrayList 的迭代器具有弱一致性，在迭代過程中，迭代器可能無法反映出最新的修改，可能會遺漏或重復元素。如果非要強一致性，那就需要全局鎖或分布式鎖來處理了。
大多數(shù)場景中，更多的還是讀多寫少；
所以一般解決并發(fā)的方法，其實就是讓并發(fā)寫的操作，變成串行的；如果非要保證最終的強一致性，那肯定最終還是串行化處理，非常影響性能。
如果是分布式系統(tǒng)的話，那肯定就要使用分布式鎖來處理了。

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: