当前位置：首页 > Java

java队列如何加锁

2026-03-22 06:47:39Java

加锁实现线程安全队列

在Java中实现线程安全的队列通常可以通过内置的并发队列或手动加锁机制完成。以下是两种常见方法：

使用java.util.concurrent包中的并发队列 Java提供了多种线程安全的队列实现，如ConcurrentLinkedQueue（非阻塞）、LinkedBlockingQueue（阻塞）和ArrayBlockingQueue（阻塞）。这些队列内部已经实现了线程安全机制，无需手动加锁。

java队列如何加锁

ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
queue.offer("item"); // 线程安全的入队操作
String item = queue.poll(); // 线程安全的出队操作

手动加锁实现同步队列 如果需要自定义队列行为，可以使用ReentrantLock或synchronized关键字实现同步：

java队列如何加锁

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

public class LockedQueue<T> {
    private final LinkedList<T> list = new LinkedList<>();
    private final ReentrantLock lock = new ReentrantLock();

    public void enqueue(T item) {
        lock.lock();
        try {
            list.addLast(item);
        } finally {
            lock.unlock();
        }
    }

    public T dequeue() {
        lock.lock();
        try {
            return list.isEmpty() ? null : list.removeFirst();
        } finally {
            lock.unlock();
        }
    }
}

使用`synchronized`关键字

对于简单的同步需求，可以直接使用synchronized修饰方法或代码块：

public class SynchronizedQueue<T> {
    private final LinkedList<T> list = new LinkedList<>();

    public synchronized void enqueue(T item) {
        list.addLast(item);
    }

    public synchronized T dequeue() {
        return list.isEmpty() ? null : list.removeFirst();
    }
}

条件变量实现阻塞队列

当需要实现生产者-消费者模型时，可以结合ReentrantLock和Condition实现阻塞等待：

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

public class BlockingLockedQueue<T> {
    private final LinkedList<T> list = new LinkedList<>();
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition();

    public void enqueue(T item) {
        lock.lock();
        try {
            list.addLast(item);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public T dequeue() throws InterruptedException {
        lock.lock();
        try {
            while (list.isEmpty()) {
                notEmpty.await();
            }
            return list.removeFirst();
        } finally {
            lock.unlock();
        }
    }
}