Java 同步队列是否在每个提供/出售上创建线程？

我不明白这是怎么回事。 我理解这个想法，任务的移交是直接交给线程的，但是构造函数没有一个界限，比如像其他API一样的最大线程数。 那么，当看跌期权或要约完成时，它本质上是传递给另一个线程还是不传递？ 因此，如果我这样做，例如100 put，它将被传递到100个线程？ 我试图阅读源代码，但不知道会发生什么。它似乎创建了一个节点的链接列表，其中每个节点封装了一个线程，但如何维护该列表，例如展开/收缩等，以及踏板如何运行任务，我并不清楚。 那么，当我们提供任务时，这个列表会扩展吗？结果消费者和服务员不断增加？

---

这些都是重复使用的吗？或者只是执行某个操作并停止？

听起来您误解了SynchronousQueue的用途

SynchronousQueue不创建任何线程。 调用put时，put不会完成，直到您创建的另一个线程将该元素从SynchronousQueue中取出

如果我这样做，例如100 put如果有100个线程，每个调用都放在同一个SynchronousQueue上，那么所有这些线程都将等待，直到其他线程开始拿走这些元素。如果您有一个线程，它一次只执行一个put，每次它都会等待另一个线程在添加另一个元素之前获取该元素

---

内部使用的列表是一个链表，它会像链表一样展开并获取GC。

听起来您误解了SynchronousQueue的用途

SynchronousQueue不创建任何线程。 调用put时，put不会完成，直到您创建的另一个线程将该元素从SynchronousQueue中取出

如果我这样做，例如100 put如果有100个线程，每个调用都放在同一个SynchronousQueue上，那么所有这些线程都将等待，直到其他线程开始拿走这些元素。如果您有一个线程，它一次只执行一个put，每次它都会等待另一个线程在添加另一个元素之前获取该元素

内部使用的列表是一个链表，它会像链表一样展开并获取GC

我理解，这种想法是将任务移交给线程 直接，但构造函数没有界限，例如 线程与其他API类似

首先，队列实现的构造函数中的int参数是大小而不是线程数

那么，当我们提供任务时，这个列表会扩展吗？因此 消费者服务生不断增加

同步队列用于切换目的。来自生产者的put调用将被阻止，直到有消费者从队列中提取。这与线程数无关。使用者线程不一定要增加。一旦消费者完成了一条消息的处理，它就可以再次从队列中提取消息

public class MyWorker extends Thread {
    private final BlockingQueue<String> queue;
    public MyWorker(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            while ( true ) {
                String s = queue.take();
                doWork(s);
            }
        }
        catch ( InterruptedException ie ) { 
            // just terminate
        }
    }
}

public class SyncQueueExample {
    // …    
    public SyncQueueExample() {
        try {
            int workItem = 0;
            // Create a synchronous queue
            BlockingQueue<String> queue = new SynchronousQueue<String>();

            // Create the child worker thread
            MyWorker worker = new MyWorker(queue);
            worker.start();

            // Start sending to the queue
            while ( true ) {
                System.out.println("\nPlacing work on queue");
                String work = "Work Item:" + (++workItem);
                queue.put(work);
            }
        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }
}

更多关于

我理解，这种想法是将任务移交给线程 直接，但构造函数没有界限，例如 线程与其他API类似

首先，队列实现的构造函数中的int参数是大小而不是线程数

那么，当我们提供任务时，这个列表会扩展吗？因此 消费者服务生不断增加

同步队列用于切换目的。来自生产者的put调用将被阻止，直到有消费者从队列中提取。这与线程数无关。使用者线程不一定要增加。一旦消费者完成了一条消息的处理，它就可以再次从队列中提取消息

public class MyWorker extends Thread {
    private final BlockingQueue<String> queue;
    public MyWorker(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            while ( true ) {
                String s = queue.take();
                doWork(s);
            }
        }
        catch ( InterruptedException ie ) { 
            // just terminate
        }
    }
}

public class SyncQueueExample {
    // …    
    public SyncQueueExample() {
        try {
            int workItem = 0;
            // Create a synchronous queue
            BlockingQueue<String> queue = new SynchronousQueue<String>();

            // Create the child worker thread
            MyWorker worker = new MyWorker(queue);
            worker.start();

            // Start sending to the queue
            while ( true ) {
                System.out.println("\nPlacing work on queue");
                String work = "Work Item:" + (++workItem);
                queue.put(work);
            }
        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }
}

---

更多关于

如果我的一个线程获取了另一个线程放入的数据，那么链表需要什么？需要的是，您可能有100个线程，每个线程都有一个等待获取的元素。因此，如果我有X个线程需要执行此队列的工作，我如何根据负载调整X个线程数？也就是说，相应地增加/减少它们？在这种情况下，SynchronousQueue实际上可能不是您想要的数据结构-可能不是将对象放入队列中，您应该将它们作为任务提交给Executors.newCachedThreadPool。如果我的一个线程获取了我的另一个线程放置的数据，那么需要链接列表吗？需要的是您可能有100个线程，每个队列都有一个等待执行的元素。因此，如果有X个线程需要执行此队列的工作，如何根据负载调整X个线程数？也就是说，相应地增加/减少它们？在这种情况下，SynchronousQueue实际上可能不是您想要的数据结构-也许您不应该将对象放入队列，而应该将它们作为TA提交 ks到Executors.newCachedThreadPool。