Java学习小册：Java并发容器与原子类

news2025/4/19 15:23:15

Java并发容器与原子类

在Java并发编程中，并发容器和原子类是管理共享数据的重要工具。它们提供了线程安全的数据结构和原子操作，确保在多线程环境下数据的一致性和操作的正确性。本文将深入探讨Java中的并发容器和原子类，包括它们的基本概念、使用方法、关键类及其实现原理。

并发容器

并发容器是Java中一组线程安全的集合类，它们提供了比传统集合类更高的并发性能。这些容器类位于java.util.concurrent包中。

`ConcurrentHashMap`

ConcurrentHashMap是一个线程安全的哈希表实现，允许多个线程同时读写数据。它通过分段锁机制实现了高效的并发访问。

示例代码：

import java.util.concurrent.ConcurrentHashMap;

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

        // 添加键值对
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Orange", 3);

        // 获取值
        System.out.println("Apple的数量: " + map.get("Apple"));

        // 遍历键值对
        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

`ConcurrentLinkedQueue`

ConcurrentLinkedQueue是一个基于链表的线程安全队列，适用于高并发场景下的任务队列。

示例代码：

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

        // 添加元素
        queue.add("Apple");
        queue.add("Banana");
        queue.add("Orange");

        // 获取并移除头部元素
        System.out.println("移除的元素: " + queue.poll());

        // 遍历队列
        queue.forEach(System.out::println);
    }
}

`CopyOnWriteArrayList`

CopyOnWriteArrayList是一个线程安全的列表实现，适用于读多写少的场景。每次写操作都会创建一个新的数组副本。

示例代码：

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

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

        // 添加元素
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        // 遍历列表
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 安全地修改列表
        list.add("Grapes");
        list.remove("Banana");
    }
}

原子类

原子类提供了一组用于原子操作的类，确保在多线程环境下操作的原子性和可见性。这些类位于java.util.concurrent.atomic包中。

`AtomicInteger`

AtomicInteger用于原子操作的整数类，支持无锁的原子更新。

示例代码：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    public static void main(String[] args) {
        AtomicInteger counter = new AtomicInteger(0);

        // 原子递增
        counter.incrementAndGet();
        counter.incrementAndGet();

        // 原子递减
        counter.decrementAndGet();

        System.out.println("计数器值: " + counter.get());
    }
}

`AtomicReference`

AtomicReference用于原子操作的对象引用类，支持无锁的原子更新。

示例代码：

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    public static void main(String[] args) {
        AtomicReference<String> reference = new AtomicReference<>("Apple");

        // 原子更新
        reference.compareAndSet("Apple", "Banana");
        reference.compareAndSet("Banana", "Orange");

        System.out.println("引用值: " + reference.get());
    }
}

`AtomicLongArray`

AtomicLongArray用于原子操作的长整型数组类，支持无锁的原子更新。

示例代码：

import java.util.concurrent.atomic.AtomicLongArray;

public class AtomicLongArrayExample {
    public static void main(String[] args) {
        AtomicLongArray array = new AtomicLongArray(3);

        // 初始化数组
        array.set(0, 10);
        array.set(1, 20);
        array.set(2, 30);

        // 原子递增
        array.getAndIncrement(0);
        array.getAndIncrement(1);

        // 遍历数组
        for (int i = 0; i < array.length(); i++) {
            System.out.println("索引 " + i + " 的值: " + array.get(i));
        }
    }
}