java手写并发容器

什么是并发容器

并发容器是一种能够在多个线程并发访问时保持数据一致性并具备高性能的容器。在多线程编程中，由于多个线程同时操作容器可能导致数据不一致或者出现竞态条件的问题，因此需要采用特殊的数据结构或算法来保证线程安全性。并发容器通常提供了线程安全的操作接口，以便多个线程可以安全地同时访问容器而不会导致数据不一致性或其他问题。

Java 中的并发容器是为了解决多线程环境下的线程安全访问而设计的，这种容器通常是线程安全的，能够有效地支持多线程并发访问，包括读写操作。Java 并发容器的设计通常使用了各种同步机制（如锁、原子操作等）以确保线程安全性。

一些常见的Java并发容器包括：

• ConcurrentHashMap: 具有线程安全性能的哈希表，提供了并发访问的能力。
• ConcurrentLinkedQueue: 一个线程安全的队列实现，能够支持高并发的读写操作。
• CopyOnWriteArrayList: 一种适合读多写少场景的并发容器，通过对写操作进行复制，实现读写分离。

使用并发容器可简化多线程编程的复杂性，避免显式地使用锁来同步访问，提高了代码的可读性和可维护性，并能够提升系统性能。因此，在需要在多线程环境下操作数据时，推荐使用Java提供的并发容器来确保程序的线程安全性和效率。

java手写并发容器

在 Java 中，模拟并发容器的实现可以通过使用线程安全的集合类（如 ConcurrentHashMap、ConcurrentLinkedQueue 等）或使用同步控制结构（如 synchronized 关键字、ReentrantLock 等）来实现。下面是一个使用同步控制结构的示例，演示如何模拟并发容器：

package org.example.gstjava.pojo;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrentContainer<E> {
    private final List<E> list = new ArrayList<>();
    private final ReentrantLock lock = new ReentrantLock();

    public void add(E element) {
        lock.lock();
        try {
            list.add(element);
        } finally {
            lock.unlock();
        }
    }

    public E get(int index) {
        lock.lock();
        try {
            return list.get(index);
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        lock.lock();
        try {
            return list.size();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ConcurrentContainer<Integer> container = new ConcurrentContainer<>();

        // 创建多个线程向容器中添加元素
        for (int i = 0; i < 5; i++) {
            final int element = i;
            new Thread(() -> {
                container.add(element);
                System.out.println("Added element: " + element);
            }).start();
        }

      try {
            // 让当前线程休眠2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted");
        }

        // 创建一个线程读取容器中的元素
        new Thread(() -> {
            for (int i = 0; i < container.size(); i++) {
                System.out.println("Element at index " + i + ": " + container.get(i));
            }
        }).start();
    }
}

在这个示例中，我们创建了一个名为 ConcurrentContainer 的类来模拟并发容器。容器内部使用一个 List 来存储元素，并使用 ReentrantLock 来保证线程安全操作。add() 方法用于向容器中添加元素，get() 方法用于获取容器中指定索引位置的元素，size() 方法用于获取容器中元素的数量。

在 main 方法中，我们创建了多个线程并发地向容器中添加元素，同时另一个线程读取容器中的元素。通过使用 ReentrantLock 来控制对容器的并发访问，确保操作的线程安全性。

需要注意的是，这只是一个简单的示例，实际场景中可能需要根据需求进行更复杂的设计和实现。当然，Java 同样提供了许多并发工具类（例如ConcurrentHashMap、CopyOnWriteArrayList等），在实际开发中也可以考虑使用这些类来解决并发访问的问题。

并发容器的优势

并发容器相对于传统的非并发容器（如 ArrayList、HashMap 等）具有以下优势：

1. 线程安全性：并发容器通过内部实现的线程安全机制，可以确保在多线程并发访问时数据的一致性，避免了数据竞争和并发访问导致的不确定行为。

2. 高效性能：并发容器的内部机制通常经过优化，能够在多线程环境下保持高效的性能表现。相比传统的加锁方式，使用并发容器可以更好地利用多核处理器的性能，并减少线程之间的竞争。

3. 简化代码：使用并发容器可以避免手动处理线程同步和锁机制的复杂性，简化了代码的编写和维护。开发者只需关注业务逻辑，而不用担心并发问题。

下面是一个简单的示例代码，演示了使用传统的ArrayList 和使用 CopyOnWriteArrayList（一个并发容器）的区别：

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

public class ConcurrentContainerDemo {

    public static void main(String[] args) throws InterruptedException {
        List<Integer> list = new ArrayList<>();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Non-concurrent List size: " + list.size()); // 非线程安全，可能输出小于2000

        // 使用并发容器 CopyOnWriteArrayList
        List<Integer> concurrentList = new CopyOnWriteArrayList<>();

        Runnable task2 = () -> {
            for (int i = 0; i < 1000; i++) {
                concurrentList.add(i); // 使用正确的并发容器
            }
        };

        Thread t3 = new Thread(task2);
        Thread t4 = new Thread(task2);

        t3.start();
        t4.start();

        t3.join();
        t4.join();

        System.out.println("Concurrent List size: " + concurrentList.size()); // 结果为2000，线程安全
    }
}

在上面的示例中，我们创建了两个线程分别向 ArrayList 和 CopyOnWriteArrayList 中添加元素。由于 ArrayList 是非线程安全的，多个线程并发地添加元素会导致不确定行为，最终输出的结果可能不是预期的值。而使用 CopyOnWriteArrayList 这种并发容器，可以确保在多线程访问时线程安全，输出的结果是预期的值。这展示了并发容器在多线程环境下的优势。