如何使用 Java 队列解决并发问题

在Java中，队列（Queue）是一种先进先出（FIFO）的数据结构，可以用于解决并发问题

1. 使用BlockingQueue接口：

Java提供了BlockingQueue接口，它是一个线程安全的队列实现。您可以使用此接口的子类（如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等）来创建线程安全的队列。

以下是一个使用BlockingQueue的示例：

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

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

        // 生产者线程
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    int item = queue.take();
                    System.out.println("Consumed: " + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

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

2. 使用ReentrantLock和Condition：

您还可以使用ReentrantLock和Condition来实现线程安全的队列。ReentrantLock提供了比synchronized关键字更灵活的锁定机制，而Condition允许线程在特定条件下等待或通知其他线程。

以下是一个使用ReentrantLock和Condition的示例：

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrentQueueExample {
    private static class QueueItem<T> {
        private final T item;
        private final Queue<QueueItem<T>> queue;

        public QueueItem(T item, Queue<QueueItem<T>> queue) {
            this.item = item;
            this.queue = queue;
        }
    }

    private final Queue<QueueItem<Integer>> queue = new LinkedList<>();
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition();
    private final Condition notFull = lock.newCondition();

    public void put(int item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == 10) {
                notFull.await();
            }
            queue.add(new QueueItem<>(item, queue));
            System.out.println("Produced: " + item);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            QueueItem<Integer> item = queue.poll();
            System.out.println("Consumed: " + item.item);
            notFull.signal();
            return item.item;
        } finally {
            lock.unlock();
        }
    }
}

在这个示例中，我们创建了一个泛型队列QueueItem，用于存储队列中的元素。我们使用ReentrantLock来确保线程安全，并使用Condition来处理生产者和消费者之间的同步。