内容概要

SynchronousQueue的优点在于其直接性和高效性，它实现了线程间的即时数据交换，无需中间缓存，确保了数据传输的实时性和准确性，同时，其灵活的阻塞机制使得线程同步变得简单而直观，适用于需要精确协调的生产者-消费者模型。

核心概念

假如，有一个在线购物平台，其中有一个非常关键的部分是处理用户的支付请求，当用户点击“支付”按钮后，系统需要确保用户的支付请求能够被安全、快速地处理，并且一旦处理完成，能够立即通知用户支付结果。

在这个场景中，可以将SynchronousQueue看作是一个没有容量的阻塞队列，它严格遵循FIFO（先进先出）的原则，但特殊的是，它不会保存任何元素，而是直接在不同的线程间进行传递。

当用户提交支付请求时，可以创建一个线程（或者使用一个线程池中的线程），该线程负责处理支付逻辑，这个线程会尝试将支付请求放入SynchronousQueue中，但是，由于SynchronousQueue没有容量，这个线程将会被阻塞，直到有另一个线程从队列中取出这个支付请求。

同时，还需有一个或多个线程负责处理支付结果，这些线程会不断地从SynchronousQueue中尝试取出支付请求进行处理，一旦取到支付请求，它们就会开始处理，并将处理结果返回给用户。

使用SynchronousQueue，可以确保支付请求能够按照提交的顺序进行处理，并且处理线程和消费线程之间能够实现高效的同步，当支付请求处理完成后，消费线程可以立即得到通知，并将结果返回给用户，从而提高了系统的响应速度和用户体验。

SynchronousQueue类在Java中主要用于解决线程间的直接、同步的数据交换问题，在多线程编程中，常常会遇到多个线程需要协作完成任务的情况，有时，一个线程需要等待另一个线程提供的数据才能继续执行，此时，使用SynchronousQueue它可以确保数据的生产者和消费者之间严格的同步，即生产者线程在数据被消费者线程取走之前会一直等待，而消费者线程在没有数据可取时也会等待。

这种同步机制有助于避免多线程编程中常见的竞态条件和数据不一致问题，通过SynchronousQueue，可以确保数据在多个线程之间安全、有序地传递，从而提高程序的稳定性和可靠性。

代码案例

下面是一个简单的Java程序，创建了一个生产者线程和一个消费者线程，演示了如何使用SynchronousQueue类，如下代码：

import java.util.concurrent.SynchronousQueue;  
import java.util.concurrent.TimeUnit;  

public class SynchronousQueueDemo {
   
     

    public static void main(String[] args) throws InterruptedException {
   
     
        // 创建一个SynchronousQueue实例  
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();  

        // 创建一个生产者线程  
        Thread producerThread = new Thread(() -> {
   
     
            try {
   
     
                // 模拟生产数据的过程  
                TimeUnit.SECONDS.sleep(1);  
                int data = 42; // 假设这是生产的数据  

                // 将数据放入SynchronousQueue中，如果此时没有消费者线程等待，生产者线程将会被阻塞  
                queue.put(data);  
                System.out.println("生产者线程: 数据 " + data + " 已被放入队列。");  
            } catch (InterruptedException e) {
   
     
                e.printStackTrace();  
            }  
        });  

        // 创建一个消费者线程  
        Thread consumerThread = new Thread(() -> {
   
     
            try {
   
     
                // 从SynchronousQueue中取出数据，如果没有数据可取，消费者线程将会被阻塞  
                int data = queue.take();  

                // 模拟消费数据的过程  
                TimeUnit.SECONDS.sleep(1);  
                System.out.println("消费者线程: 数据 " + data + " 已被消费。");  
            } catch (InterruptedException e) {
   
     
                e.printStackTrace();  
            }  
        });  

        // 启动生产者和消费者线程  
        producerThread.start();  
        consumerThread.start();  

        // 等待两个线程执行完毕  
        producerThread.join();  
        consumerThread.join();  

        System.out.println("主线程: 程序执行完毕。");  
    }  
}

在上面的代码中，创建了一个SynchronousQueue实例，并通过它来进行线程间的数据交换。

生产者线程模拟生产数据的过程，并通过put方法将数据放入队列中，如果此时没有消费者线程等待数据，生产者线程将会被阻塞，消费者线程通过take方法从队列中取出数据，并进行消费，如果队列中没有数据可取，消费者线程将会被阻塞。

运行上面的代码，输出如下类似内容：

生产者线程: 数据 42 已被放入队列。  
消费者线程: 数据 42 已被消费。  
主线程: 程序执行完毕。

核心API

SynchronousQueue 是一个没有容量的阻塞队列，每个插入操作必须等待一个相应的删除操作，反之亦然，它主要用于在线程之间进行直接、同步的数据交换，以下是 SynchronousQueue 类中主要方法的含义：

1、put(E e)

• 将指定的元素插入此队列中，如果另一个线程正在等待接收它，则立即将其移交给该线程，否则等待直到有线程来取。
• 由于 SynchronousQueue 是一个没有容量的队列，put 方法将会阻塞直到有消费者线程通过 take 或 poll 方法来移除这个元素。

2、take()

• 移除并返回此队列的头部，在元素变得可用之前一直等待。
• 如果没有元素可用，take 方法将会阻塞直到有生产者线程通过 put 方法来提供一个元素。

3、offer(E e)

• 将指定的元素插入此队列中，如果另一个线程正在等待接收它，则立即将其移交给该线程，并返回 true，否则立即返回 false。
• 这个方法是非阻塞的，如果队列中没有等待的消费者，它会立即返回 false。

4、offer(E e, long timeout, TimeUnit unit)

• 将指定的元素插入此队列中，等待指定的时间以使另一个线程接收它，如果在指定的时间内没有线程等待，则返回 false。
• 这个方法允许生产者在放弃之前等待一段时间，以看是否有消费者线程能够接收元素。

5、poll()

• 移除并返回此队列的头部，如果此队列为空，则返回 null。
• 这个方法是非阻塞的，它立即返回队列中的头部元素，如果队列为空则返回 null。

6、poll(long timeout, TimeUnit unit)

• 移除并返回此队列的头部，在指定的时间内等待元素变得可用，如果在指定的时间内队列仍然为空，则返回 null。
• 这个方法允许消费者在放弃之前等待一段时间，以看是否有生产者线程能够提供元素。

7、peek()

• 检索但不移除此队列的头部，如果此队列为空，则返回 null。
• 这个方法是非阻塞的，它仅仅查看队列的头部而不移除它。

8、isEmpty()

• 检查此队列是否为空。
• 对于 SynchronousQueue 来说，这个方法可能不是特别有用，因为它没有容量，且其状态是瞬时的，可能在调用此方法后立即改变。

9、clear()

• 由于 SynchronousQueue 是一个没有容量的队列，此方法实际上没有什么可做的，调用它不会有任何效果。

10、remainingCapacity()

• 对于 SynchronousQueue，此方法始终返回 0，因为队列没有容量。

11、drainTo(Collection<? super E> c)

• 将此队列中所有可用的元素都移除，并将它们添加到给定的集合中。
• 由于 SynchronousQueue 是一个没有容量的队列，这个方法通常不会移除任何元素，除非在调用此方法时恰好有元素在等待被消费。

12、drainTo(Collection<? super E> c, int maxElements)

• 将此队列中最多给定数量的可用元素移除，并将它们添加到给定的集合中。
• 和 drainTo(Collection<? super E> c) 方法类似，但由于 SynchronousQueue 的特性，这个方法通常也不会移除任何元素。

核心总结

SynchronousQueue类是一个无缓冲的、基于阻塞的队列，专门用于线程间的数据传输，它的主要优点体现在其高效性和直接性上：

优点：

1. 高效性：直接传递对象，不需要像其他队列那样进行数据的复制或移动，从而提高了数据传输的效率。
2. 直接性：每个插入操作都必须等待一个相应的删除操作，反之亦然，这使得线程间的数据交换更加直接和明确。
3. 灵活性：通过put和take方法的结合使用，可以在生产者线程和消费者线程之间实现灵活的同步。

缺点：

1. 阻塞性：由于SynchronousQueue的无缓冲特性，当没有匹配的生产者或消费者线程时，线程会被阻塞，这可能导致性能下降。

使用建议：

1. 适用于低延迟场景：适用于需要低延迟的线程间通信场景，如生产者-消费者模型中的精确同步。
2. 避免长时间等待：在使用SynchronousQueue时，应尽量避免线程长时间等待，可以通过设置合理的超时时间或使用其他同步机制来优化。

END!
END!
END!

往期回顾

精品文章

Java并发基础：Exchanger全面解析！

Java并发基础：ConcurrentLinkedDeque全面解析！

Java并发基础：PriorityBlockingQueue全面解析！

Java并发基础：DelayQueue全面解析！

Java并发基础：LinkedBlockingDeque全面解析！

精彩视频