Java中常用的并发容器总结。

  在Java中有很多常用的并发容器，使用它们可以保证多线程操作的安全性数据操作，下面介绍一下常见的并发容器，并结合代码详细说明一下它们的使用用法。

1. ConcurrentHashMap

ConcurrentHashMap是线程安全的哈希表实现，适用于在多线程环境下进行并发读写操作。

代码如下：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        map.put("A", 1);
        map.put("B", 2);

        System.out.println("Initial map: " + map);

        map.compute("A", (key, value) -> value + 10); // 使用compute方法更新值

        System.out.println("Updated map: " + map);
    }
}
  

2. CopyOnWriteArrayList：

CopyOnWriteArrayList是线程安全的ArrayList实现，适用于读多写少的场景。在写操作时会创建一个新的数组，保证读写操作不会相互干扰。
代码如下：

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

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        List<Integer> list = new CopyOnWriteArrayList<>();

        list.add(1);
        list.add(2);

        System.out.println("Initial list: " + list);

        list.add(3); // 写操作

        System.out.println("Updated list: " + list);
    }
}

3. BlockingQueue：

BlockingQueue是一个阻塞队列接口，常用的实现类有LinkedBlockingQueue和ArrayBlockingQueue等，用于在多线程环境下进行生产者消费者模式的数据交换。
代码如下：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        new Thread(() -> {
            try {
                queue.put(1);
                queue.put(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                System.out.println("Take from queue: " + queue.take());
                System.out.println("Take from queue: " + queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}