Java并发编程 - 集合类不安全

用心去追梦

于 2024-08-17 10:04:04 发布

阅读量287

点赞数 3

文章标签： java 安全 python

本文链接：https://blog.csdn.net/qq_33240556/article/details/141276283

版权

在Java并发编程中，集合类的安全性是一个重要的话题。默认情况下，Java标准库中大多数集合类（如ArrayList、LinkedList、HashMap等）在多线程环境下不是线程安全的。这意味着如果不采取适当的同步措施，这些集合类在多线程环境中可能会引发数据不一致、竞态条件等问题。

不安全的原因

集合类不安全的原因主要有以下几点：

并发修改异常 (ConcurrentModificationException)：
- 当一个线程正在遍历集合时，另一个线程修改了集合的内容（如添加或删除元素），这时遍历线程可能会抛出ConcurrentModificationException异常。
数据不一致性：
- 如果多个线程同时访问并修改集合，可能会导致数据不一致或丢失。
竞态条件 (Race Condition)：
- 当多个线程试图同时修改集合时，可能会出现竞态条件，导致数据错误。

解决方案

为了确保集合类在多线程环境下的安全性，可以采取以下几种策略：

同步容器 (Collections.synchronized*):
- 可以使用Collections.synchronizedList、Collections.synchronizedSet等方法将集合包装成线程安全的版本。
- 例如：
```
List<String> list = Collections.synchronizedList(new ArrayList<>());
```
并发容器 (java.util.concurrent包):
- 使用java.util.concurrent包中的并发容器，如CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap等。
- 这些容器内部已经实现了线程安全的机制。
- 例如：
```
List<String> list = new CopyOnWriteArrayList<>();
Map<String, String> map = new ConcurrentHashMap<>();
```

显式同步:

显式地使用锁来同步对集合的访问。

例如：

private final Object lock = new Object();
private final List<String> list = new ArrayList<>();

public void add(String item) {
    synchronized (lock) {
        list.add(item);
    }
}

public String get(int index) {
    synchronized (lock) {
        return list.get(index);
    }
}

不变容器 (Collections.unmodifiable*):
- 使用Collections.unmodifiableList等方法创建不可变的集合。
- 这种方法适用于只读场景，但需要注意不可变容器仍然可以被替换，所以最好将其声明为final。
- 例如：
```
List<String> list = Collections.unmodifiableList(new ArrayList<>());
```

使用ReentrantLock:

使用ReentrantLock代替synchronized关键字来提供更细粒度的控制。

例如：

private final ReentrantLock lock = new ReentrantLock();
private final List<String> list = new ArrayList<>();

public void add(String item) {
    lock.lock();
    try {
        list.add(item);
    } finally {
        lock.unlock();
    }
}

示例代码

下面是一个使用CopyOnWriteArrayList的简单示例，该容器是线程安全的：

import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class ConcurrentListExample {

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

    public void add(String item) {
        list.add(item);
    }

    public void print() {
        for (String item : list) {
            System.out.println(item);
        }
    }

    public static void main(String[] args) {
        ConcurrentListExample example = new ConcurrentListExample();

        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                example.add("Item " + i);
            }
        });

        Thread consumer = new Thread(() -> {
            Iterator<String> iterator = example.list.iterator();
            while (iterator.hasNext()) {
                System.out.println(iterator.next());
            }
        });

        producer.start();
        consumer.start();

        try {
            producer.join();
            consumer.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}