多线程基础（六、五）BlockingQueue用法详解之SynchronousQueue

明湖起风了

已于 2023-06-17 09:44:41 修改

阅读量203

点赞数

分类专栏： Java并发编程文章标签： java 开发语言

于 2023-06-17 09:44:05 首次发布

原文链接：https://juejin.cn/post/7031196740128768037

版权

Java并发编程专栏收录该内容

20 篇文章 7 订阅

订阅专栏

理解SynchronousQueue

SynchronousQueue，实际上它不是一个真正的队列，因为SynchronousQueue没有容量。与其他BlockingQueue（阻塞队列）不同,SynchronousQueue是一个不存储元素的BlockingQueue。只是它维护一组线程，这些线程在等待着把元素加入或移出队列。

我们简单分为以下几种特点：

内部没有存储（容量为0）
阻塞队列（也是blockingqueue的一个实现）
发送或者消费线程会阻塞，只有有一对消费和发送线程匹配上，才同时退出。
配对有公平模式和非公平模式(默认)

为了演示我们上面所分析的特么下面根据实例代码演示下：

代码案例

/**
 * SynchronousQueue队列演示demo
 * @Date 2021/11/16 11:10 下午
 * @Author yn
 */
public class SynchronousQueueDemo {

    public static void main(String[] args) {
        SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "\t 入队列 1");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "\t 入队列 2");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "\t 入队列 3");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "AAAAA").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName() + "\t 出队列 " + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName() + "\t 出队列 " + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName() + "\t 出队列 " + synchronousQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BBBBB").start();
    }
}

看下控制台打印

AAAAA 入队列 1 
BBBBB 出队列 1 

AAAAA 入队列 2 
BBBBB 出队列 2 

AAAAA 入队列 3 
BBBBB 出队列 3

看到没，这个就是开头所说“配对”队列，也就是验证了入和出必须是配对的。否则阻塞。

所以说这是一个很有意思的阻塞队列，其中每个插入操作必须等待另一个线程的移除操作，同样任何一个移除操作都等待另一个线程的插入操作。因此此队列内部其实没有任何一个元素，因此不能调用peek操作，因为只有移除元素时才有元素。

我们接下来看下它的应用场景

应用场景

我们拿newCachedThreadPool线程池来了解下

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
}

SynchronousQueue的一个使用场景是在线程池里。Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。

由于ThreadPoolExecutor内部实现任务提交的时候调用的是工作队列（BlockingQueue接口的实现类）的非阻塞式入队列方法（offer方法），因此，在使用SynchronousQueue作为工作队列的前提下，客户端代码向线程池提交任务时，而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务，那么相应的offer方法调用就会失败（即任务没有被存入工作队列）。

此时，ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理（假设此时线程池的大小还未达到其最大线程池大小）。

是不是设计的贼精彩。我们可以去里面跟一下代码

简单看下源码

开头说过，SynchronousQueue 与其他BlockingQueue一样，SynchronousQueue同样继承AbstractQueue和实现BlockingQueue接口：

SynchronousQueue提供了两个构造函数：

public SynchronousQueue(boolean fair) {
        // 通过 fair 值来决定公平性和非公平性
        // 公平性使用TransferQueue，非公平性采用TransferStack
        transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
    }

TransferQueue、TransferStack继承Transferer，Transferer为SynchronousQueue的内部类，它提供了一个方法transfer()，该方法定义了转移数据的规范，如下：

abstract static class Transferer<E> {
        abstract E transfer(E e, boolean timed, long nanos);
    }

transfer()方法主要用来完成转移数据的，如果e != null，相当于将一个数据交给消费者，如果e == null，则相当于从一个生产者接收一个消费者交出的数据。

总结

使用SynchronousQueue的目的就是保证 “对于提交的任务，如果有空闲线程，则使用空闲线程来处理；否则新建一个线程来处理任务”。

SynchronousQueue也是blockingqueue的一个实现，内部采用的就是ArrayBlockingQueue的阻塞原语，所以在功能上完全可以用ArrayBlockingQueue替换之，但是SynchronousQueue 是轻量级的，SynchronousQueue 不具有任何内部容量，甚至不具有一的容量，我们可以用来在线程间安全的交换单一元素。所以功能比较单一，优势应该就在于轻量