SynchronousQueue（同步队列）简单了解

  SynchronousQueue（同步队列）最大的特点就是它没有容量, 没有线程来取内容之前是没有内容能放进去的(一手交钱一手交货

1.特点:

            不储存元素:  SynchronousQueue 队列并不像ArrayBlockQueue或者是LinkedBlockingQueue一样,它并不存储元素,每线程一个插入的操作必须等待另一个线程的移除操作,反之亦然.换句话说就是SysChronousQueue是不存储元素的,是线程和线程之间直接传递    

    一种线程协作机制：SynchronousQueue 提供了一种线程之间的协作机制，其中一个线程试图将元素放入队列，而另一个线程试图从队列中取出元素。只有当两个线程相遇时，元素才会被插入或者移除。这种机制使得 SynchronousQueue 非常适合用于传递元素的场景，例如生产者-消费者模型中，生产者线程和消费者线程之间的协作。

    公平性选择：SynchronousQueue 提供了两种构造方法，一种是默认非公平的，另一种是公平的。在公平模式下，等待时间较长的线程会优先得到插入或者移除元素的机会，而在非公平模式下，线程的获取顺序是不确定的。

 2.使用场景

SynchronousQueue 的特性决定了它适用于特定的场景，主要用于实现直接的、点对点的线程间通信。以下是一些常见的使用场景：

生产者-消费者模型：SynchronousQueue 可以作为生产者和消费者线程之间的传递数据的通道。在这种模型中，生产者将数据放入 SynchronousQueue，消费者线程会等待数据的到来并消费它。

线程池任务执行：在 ThreadPoolExecutor 中，如果使用无界队列，可能会导致队列中堆积大量的任务，造成内存耗尽。而使用 SynchronousQueue 作为任务队列，可以让提交的任务直接交给工作线程，避免任务堆积。

传递信号：SynchronousQueue 可以用于在多个线程之间传递信号，例如当某个条件满足时，一个线程通知另一个线程进行操作。一个线程将信号放入 SynchronousQueue，另一个线程从中取出信号。

实现生产者-消费者的异步模式：通过 SynchronousQueue，生产者线程可以立即返回而不需要等待消费者处理完成。这种异步模式可以在一定场景下提高系统的响应速度。

需要注意的是，SynchronousQueue 适用于非常特定的线程通信场景，通常在高并发、多线程之间需要精确控制数据流、避免任务积压等情况下使用。在其他场景中，可能会选择使用不同类型的队列，比如 ArrayBlockingQueue、LinkedBlockingQueue 等。选择合适的队列取决于具体需求，以及对于并发性、阻塞行为和内存占用的权衡。

3.简单的演示代码

package org.example.Pool;


import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.SynchronousQueue;

@Slf4j(topic = "c.TestSynchronousQueue")
public class TestSynchronousQueue {
    public static void main(String[] args) throws InterruptedException {
        //可以注意到他是没有设置大小的,所以他是无边界
        SynchronousQueue<Integer> integers = new SynchronousQueue<>();

        //开启几个线程去给它添加元素
        new Thread(()->{
            try {
                log.debug("putting:{}",1);
                integers.put(1);
                log.debug("putted:{}",1);

                log.debug("putting:{}",2);
                integers.put(2);
                log.debug("putted:{}",2);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();

        Thread.sleep(1000);
        new Thread(()->{
            try {
              log.debug("taking:{}",1);
              integers.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();
        Thread.sleep(1000);
        new Thread(()->{
            try {
                log.debug("taking:{}",2);
                integers.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t3").start();
    }

}

运行结果可以看出来来,元素得插入和元素得取出是一对一的