17370845950

使用ConcurrentLinkedQueue可实现无锁线程安全事件队列，适合高并发场景；若需阻塞等待则选用LinkedBlockingQueue；最简洁方式是封装单线程ExecutorService，由JDK保证线程安全与顺序执行。

在Java中实现线程安全的事件队列，核心是确保多个线程可以安全地添加和处理事件，避免数据竞争和不一致状态。最简单有效的方式是使用并发集合类，并结合适当的同步机制。

使用ConcurrentLinkedQueue实现无锁队列

它基于链表结构，使用 CAS 操作保证线程安全，性能优于传统的 synchronized 队列。

示例代码：

import java.util.concurrent.ConcurrentLinkedQueue;

public class EventQueue {
    private final ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue<>();

    public void post(Runnable event) {
        if (event != null) {
            queue.offer(event);
        }
    }

    public void dispatch() {
        Runnable event;
        while ((event = queue.poll()) != null) {
            event.run();
        }
    }
}

注意：dispatch 方法通常由单个消费者线程调用，比如事件循环线程，这样能保证事件有序执行。

使用BlockingQueue实现阻塞式事件队列

它天然支持多生产者-单消费者或多个消费者的线程安全模型。

示例：

import java.util.concurrent.LinkedBlockingQueue;

public class BlockingEventQueue {
    private final LinkedBlockingQueue queue = new LinkedBlockingQueue<>();

    public void post(Runnable event) {
        if (event != null) {
            queue.offer(event);
        }
    }

    public void dispatchLoop() throws InterruptedException {
        while (!Thread.currentThread().isInterrupted()) {
            Runnable event = queue.take(); // 阻塞直到有事件
            event.run();
        }
    }
}

这种方式适合后台事件处理器，避免空转消耗 CPU。

结合ExecutorService简化事件调度

可以将事件队列封装进一个单线程的 Executor，所有事件提交给这个执行器，自然保证顺序和线程安全。

示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SafeEventDispatcher {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    public void post(Runnable event) {
        executor.submit(event);
    }

    public void shutdown() {
        executor.shutdown();
    }
}

这种方法最简洁，且由 JDK 保证线程安全和资源管理，推荐用于大多数场景。

基本上就这些。选择哪种方式取决于是否需要阻塞、是否关注事件顺序、以及系统的性能要求。使用标准库的并发工具类，能有效避免手动同步带来的复杂性和潜在 bug。