Java中SynchronousQueue使用技巧

SynchronousQueue不存储元素，每次插入需等待移除，适用于线程间直接数据传递；公平模式确保等待时间最长的线程优先，避免饥饿，适合实时系统，但性能开销大；非公平模式提升吞吐量，减少上下文切换，适合高并发场景如日志处理；put()和take()方法阻塞直至配对线程就绪，实现数据同步传递；tryTransfer()可非阻塞尝试传递数据，支持超时，提高响应性；Executors.newCachedThreadPool()使用SynchronousQueue，动态创建线程执行短期任务，但可能因无限制创建线程导致资源耗尽；避免死锁需防止循环等待，不应在同一线程中同时调用put()和take()，建议使用超时或外部协调机制。

SynchronousQueue本质上是一种特殊的阻塞队列，它不存储任何元素。 每次插入操作必须等待一个相应的移除操作，反之亦然。 想象一下，它就像一个电话亭，只有当有人打电话进来，同时有人在里面等待接听，这个通话才能建立。 这使得它非常适合在线程之间直接传递数据，特别是在生产者-消费者模式中。

SynchronousQueue使用技巧

如何选择公平模式和非公平模式的SynchronousQueue？

SynchronousQueue提供了公平和非公平两种模式，通过构造函数中的

fair

new SynchronousQueue<>(true)

new SynchronousQueue<>(false)

选择哪种模式取决于你的应用场景。 如果你需要确保每个线程都有公平的机会获得资源，避免饥饿现象，那么公平模式是更好的选择。 然而，公平模式通常会带来更高的性能开销，因为它需要维护等待队列的顺序。

立即学习“Java免费学习笔记（深入）”；

非公平模式则可能提供更高的吞吐量，因为它允许线程竞争资源，减少了上下文切换的开销。 但需要注意的是，非公平模式可能导致某些线程长时间无法获得资源，从而影响系统的整体响应时间。

例如，在构建一个高性能的日志系统时，我们可能更倾向于使用非公平模式，因为日志处理的吞吐量比单个线程的公平性更重要。 而在构建一个实时交易系统时，我们可能需要使用公平模式，以确保每个交易请求都能得到及时处理。

// 公平模式
SynchronousQueue fairQueue = new SynchronousQueue<>(true);

// 非公平模式
SynchronousQueue unfairQueue = new SynchronousQueue<>(false);

SynchronousQueue的

put()

和

take()

方法是如何工作的？

put()

put()

take()

take()

put()

这种阻塞机制使得SynchronousQueue成为线程之间直接交换数据的理想选择。 想象一下，一个线程调用

put()

take()

// 生产者线程
new Thread(() -> {
    try {
        System.out.println("生产者准备放入数据");
        fairQueue.put("Hello, World!");
        System.out.println("生产者放入数据完成");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

// 消费者线程
new Thread(() -> {
    try {
        Thread.sleep(1000); // 模拟一些耗时操作
        System.out.println("消费者准备获取数据");
        String message = fairQueue.take();
        System.out.println("消费者获取到数据: " + message);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

如何使用

tryTransfer()

方法进行非阻塞的数据传递？

tryTransfer()

false

一款简单实用的弹窗插件JMask

JMask是一款遮罩插件，其小巧灵活，在项目开发中方便实用。使用方式也特别简单，只需要引入一个js文件，该插件基于JQuery开发，所以使用之前需要引入JQuery文件。

下载

tryTransfer()

false

使用

tryTransfer()

tryTransfer()

// 生产者线程
new Thread(() -> {
    try {
        System.out.println("生产者尝试放入数据");
        boolean transferred = fairQueue.tryTransfer("Hello, World!", 500, TimeUnit.MILLISECONDS);
        if (transferred) {
            System.out.println("生产者放入数据成功");
        } else {
            System.out.println("生产者放入数据失败，没有消费者等待");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

// 消费者线程
new Thread(() -> {
    try {
        Thread.sleep(1000); // 模拟一些耗时操作
        System.out.println("消费者准备获取数据");
        String message = fairQueue.take();
        System.out.println("消费者获取到数据: " + message);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

SynchronousQueue在线程池中的应用：

Executors.newCachedThreadPool()

Executors.newCachedThreadPool()

这种机制使得

newCachedThreadPool()

然而，

newCachedThreadPool()

newCachedThreadPool()

ExecutorService executor = Executors.newCachedThreadPool();

for (int i = 0; i < 10; i++) {
    final int taskIndex = i;
    executor.execute(() -> {
        try {
            System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行任务 " + taskIndex);
            Thread.sleep(1000); // 模拟一些耗时操作
            System.out.println("线程 " + Thread.currentThread().getName() + " 完成任务 " + taskIndex);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

executor.shutdown();

如何避免在使用SynchronousQueue时出现死锁？

使用SynchronousQueue时，最常见的死锁情况是当两个线程都在互相等待对方释放资源时发生。 例如，线程A尝试

put()

take()

为了避免死锁，需要仔细设计线程之间的交互逻辑，确保不会出现循环等待的情况。 可以考虑使用超时机制，或者使用更复杂的同步机制来协调线程之间的操作。

另外，避免在一个线程中同时进行

put()

take()

put()

take()