在Java中，ArrayList、LinkedList等常見List實現(xiàn)類不是線程安全的（非同步）。當多個線程同時對其進行修改（如add、remove）或讀寫操作時，可能會導致數(shù)據(jù)不一致、ConcurrentModificationException（并發(fā)修改異常）等問題。

要在多線程環(huán)境下安全地修改List，需通過線程安全的容器或同步機制保證操作的原子性和可見性。以下是常用解決方案及實現(xiàn)方式：

一、使用線程安全的List實現(xiàn)類

Java提供了幾種線程安全的List實現(xiàn)，可直接替換非線程安全的List，無需手動處理同步。

1.Vector（古老實現(xiàn)，不推薦）

Vector是Java早期的線程安全List實現(xiàn)，其所有方法都被synchronized修飾（同步方法），保證線程安全。
缺點：同步粒度太粗（整個方法加鎖），多線程并發(fā)效率低，且功能上被更優(yōu)的方案替代，不推薦在新代碼中使用。

// Vector是線程安全的，但性能較差
List<String> vector = new Vector<>();
// 多線程可安全調(diào)用add/remove等方法
vector.add("A");
vector.remove(0);

2.Collections.synchronizedList()（包裝同步，推薦基礎場景）

Collections工具類的synchronizedList()方法可將任意非線程安全的List包裝為線程安全的List。其原理是對所有方法添加同步鎖（使用synchronized塊），保證同一時刻只有一個線程能操作List。

使用方式：

// 1. 創(chuàng)建非線程安全的List（如ArrayList）
List<String> unsafeList = new ArrayList<>();
// 2. 包裝為線程安全的List
List<String> safeList = Collections.synchronizedList(unsafeList);
// 多線程環(huán)境下可安全操作
// 線程1：添加元素
new Thread(() -> {
    safeList.add("A");
}).start();
// 線程2：刪除元素
new Thread(() -> {
    if (!safeList.isEmpty()) {
        safeList.remove(0);
    }
}).start();

注意事項：

迭代操作需手動加鎖：synchronizedList返回的List在迭代時（如for-each、iterator）不自動同步，需手動用synchronized塊包裹，否則可能拋出ConcurrentModificationException。

// 迭代時必須手動同步（鎖對象為safeList本身）
synchronized (safeList) {
    for (String s : safeList) {
        System.out.println(s);
    }
}

適合讀寫頻率均衡的場景：由于所有操作都加鎖，高并發(fā)下性能一般，但實現(xiàn)簡單，適合大多數(shù)基礎場景。

3.CopyOnWriteArrayList（寫時復制，推薦讀多寫少場景）

CopyOnWriteArrayList是Java并發(fā)包（java.util.concurrent）提供的線程安全List，其核心原理是**“寫時復制”**：

• 讀操作：無需加鎖，直接訪問當前數(shù)組（性能極高）。
• 寫操作（add、remove等）：先復制一份新的數(shù)組，在新數(shù)組上修改，然后將引用指向新數(shù)組（修改時加鎖，保證原子性）。

適用場景：讀操作遠多于寫操作（如緩存、配置列表），寫操作頻率低但讀操作需高效。

使用方式：

import java.util.concurrent.CopyOnWriteArrayList;
// 初始化線程安全的CopyOnWriteArrayList
List<String> cowList = new CopyOnWriteArrayList<>();
// 多線程安全操作
// 線程1：添加元素（寫操作，會復制數(shù)組）
new Thread(() -> {
    cowList.add("A");
}).start();
// 線程2：讀取元素（讀操作，無鎖，直接訪問）
new Thread(() -> {
    for (String s : cowList) {
        System.out.println(s);
    }
}).start();

優(yōu)點：

• 讀操作無鎖，并發(fā)性能極佳（適合讀多寫少）。
• 迭代時不會拋出ConcurrentModificationException（迭代的是舊數(shù)組的快照）。

缺點：

• 寫操作成本高（復制數(shù)組，內(nèi)存占用翻倍）。
• 數(shù)據(jù)實時性差（讀操作可能訪問的是舊數(shù)組，修改后的數(shù)據(jù)需等新數(shù)組替換后才能被讀?。?。

二、手動同步（鎖機制）

如果需要更靈活地控制同步粒度（如僅對關鍵修改操作加鎖），可使用synchronized關鍵字或Lock接口手動實現(xiàn)同步。

1. 使用synchronized塊

通過synchronized鎖定List對象或其他鎖對象，保證同一時刻只有一個線程執(zhí)行修改操作。

List<String> list = new ArrayList<>();
// 定義鎖對象（也可直接用list本身作為鎖）
Object lock = new Object();
// 線程1：添加元素
new Thread(() -> {
    synchronized (lock) { // 加鎖
        list.add("A");
    }
}).start();
// 線程2：刪除元素
new Thread(() -> {
    synchronized (lock) { // 加鎖
        if (!list.isEmpty()) {
            list.remove(0);
        }
    }
}).start();

2. 使用ReentrantLock（可重入鎖）

java.util.concurrent.locks.ReentrantLock提供比synchronized更靈活的鎖控制（如超時鎖、公平鎖），適合復雜場景。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
List<String> list = new ArrayList<>();
// 創(chuàng)建鎖對象（可指定為公平鎖，按請求順序獲取鎖）
Lock lock = new ReentrantLock(true);
// 線程1：添加元素
new Thread(() -> {
    lock.lock(); // 加鎖
    try {
        list.add("A");
    } finally {
        lock.unlock(); // 必須在finally中釋放鎖，避免死鎖
    }
}).start();
// 線程2：刪除元素
new Thread(() -> {
    lock.lock(); // 加鎖
    try {
        if (!list.isEmpty()) {
            list.remove(0);
        }
    } finally {
        lock.unlock();
    }
}).start();

三、注意事項

• 復合操作的原子性：
  • 即使使用線程安全的List，復合操作（如“先判斷再修改”）仍需額外同步。例如：

// 錯誤示例：contains和add是兩個獨立操作，可能被其他線程打斷
if (!safeList.contains("A")) { 
    safeList.add("A"); // 可能重復添加
}
// 正確：用同步塊保證復合操作原子性
synchronized (safeList) {
    if (!safeList.contains("A")) {
        safeList.add("A");
    }
}

• 迭代器的線程安全：
  • synchronizedList的迭代器需手動同步（見上文）。
  • CopyOnWriteArrayList的迭代器是“快照迭代器”，不支持remove、add等修改操作（會拋UnsupportedOperationException），只能遍歷。
• 性能權(quán)衡：
  • 讀多寫少：優(yōu)先CopyOnWriteArrayList（讀無鎖）。
  • 讀寫均衡或?qū)懖僮黝l繁：優(yōu)先Collections.synchronizedList()或手動鎖（避免CopyOnWriteArrayList的復制開銷）。
  • 避免使用Vector（性能差，已過時）。

總結(jié)

多線程安全修改List的核心是保證操作的原子性和可見性，常用方案對比：

根據(jù)實際業(yè)務的讀寫頻率和復雜度選擇合適方案即可。

到此這篇關于java中在多線程的情況下安全的修改list(常見解決方案)的文章就介紹到這了,更多相關java多線程修改list內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論