Java 中的并发集合

2024 年 9 月 10 日 | 阅读 3 分钟

Java 提供了许多数据结构，使开发人员能够有效地处理记录集合。当涉及多个线程时，**并发集合**变得至关重要，以确保数据完整性和线程安全。在本节中，我们将探讨 Java 中的并发集合，并提供代码示例来演示其用法。

Java 中的并发

Java 中的并发是指多个线程的并发执行。当多个线程访问和修改共享数据结构时，可能会出现诸如竞态条件和数据损坏等问题。为了解决这些问题，Java 在 `java.util.concurrent` 包中提供了一系列并发集合。

1. ConcurrentHashMap

ConcurrentHashMap 是 Map 接口的线程安全实现。它允许多个线程同时读取和写入，而不会相互阻塞。下面是一个示例：

ConcurrentMapExample.java

import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("one", 1);
        concurrentMap.put("two", 2);
        concurrentMap.put("three", 3);
        int value = concurrentMap.get("two");
        System.out.println("Value for key 'two': " + value);
    }
}

输出

Value for key 'two': 2

2. CopyOnWriteArrayList

CopyOnWriteArrayList 是一个线程安全的列表，其中修改会创建底层数组的全新副本。它确保在其他线程生成列表期间，实际列表保持不变。下面是一个示例：

CopyOnWriteArrayListExample.java

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);
        list.add(3);
        for (Integer num : list) {
            System.out.println(num);
        }
    }
}

输出

1
2
3

3. BlockingQueue

BlockingQueue 是一个并发队列，能够对添加和删除元素执行阻塞操作。它通常用于生产者-消费者场景。让我们看看 LinkedBlockingQueue 的用法示例：

BlockingQueueExample.java

import java.util.concurrent.LinkedBlockingQueue;
public class BlockingQueueExample {
    public static void main(String[] args) {
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        new Thread(() -> {
            try {
                queue.put(1);
                queue.put(2);
                queue.put(3);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
        try {
            System.out.println("Removed from queue: " + queue.take());
            System.out.println("Removed from queue: " + queue.take());
            System.out.println("Removed from queue: " + queue.take());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

输出

Removed from queue: 1
Removed from queue: 2
Removed from queue: 3

4. ConcurrentLinkedQueue

ConcurrentLinkedQueue 是一个非阻塞的线程安全队列。它在许多生产者-消费者场景中是一个高效的选择。

ConcurrentQueueExample.java

import java.util.concurrent.ConcurrentLinkedQueue;
public class ConcurrentQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        for (Integer num : queue) {
            System.out.println(num);
        }
    }
}

输出

1
2
3

5. ConcurrentSkipListSet

ConcurrentSkipListSet 是使用跳表实现的 SortedSet 的线程安全实现。它允许元素以排序的顺序存储，并支持并发访问。

SkipListSetExample.java

import java.util.NavigableSet;
import java.util.concurrent.ConcurrentSkipListSet;
public class SkipListSetExample {
    public static void main(String[] args) {
        NavigableSet<Integer> set = new ConcurrentSkipListSet<>();
        set.add(3);
        set.add(1);
        set.add(2);
        for (Integer num : set) {
            System.out.println(num);
        }
    }
}

输出

1
2
3

6. LinkedBlockingQueue

BlockingQueueExample.java

import java.util.concurrent.LinkedBlockingQueue;
public class BlockingQueueExample {
    public static void main(String[] args) {
        TheLinkedBlockingQueue<Integer> queue = new TheLinkedBlockingQueue<>(2);
        new Thread(() -> {
            try {
                queue.put(1);
                queue.put(2);
                queue.put(3); 
            } catch (TheInterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
        try {
            System.out.println("Delete from queue: " + queue.take());
            System.out.println("Delete from queue: " + queue.take());
            System.out.println("Delete from queue: " + queue.take());
        } catch (TheInterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

输出

Delete from queue: 1
Delete from queue: 2

总之，Java 中的并发集合是编写需要共享数据结构的并发应用程序的重要工具。它们确保线程安全并有助于防止常见的并发问题。在本文中，我们探讨了 Java 中一些基本的并发集合，并提供了代码示例来演示其用法。

通过使用这些集合，您可以编写稳定的并发 Java 程序。Java 提供了各种数据结构，使开发人员能够有效地处理数据集合。并发集合对于确保数据完整性和线程安全至关重要。

下一主题在 Java 中创建 JSON 节点

Java 中的并发集合