LinkedTransferQueue getWaitingConsumerCount()方法在Java中的示例

java.util.concurrent.LinkedTransferQueue .getWaitingConsumerCount() 方法返回等待通过take()或定时轮询从LinkedTransferQueue（LTQ）接收元素的消费者数量。这里的消费者将从LTQ中读取元素。生产者将把元素添加到LTQ中。仅当多个线程运行时，即生产者正在传输消息并且消费者正在同时接收它们时，此方法才有用。消费者将尝试读取LTQ的头。如果他们无法（空的LTQ或头部已经被取走），则称它们正在等待。消费者将等待，直到他们读取到头部，或者直到某个时间限制过期。当生产者通过transfer()将元素添加到LTQ中时，它被视为被阻塞。这意味着生产者必须等待，直到消费者读取元素以添加另一个元素到LTQ中。

语法:

public int getWaitingConsumerCount()

参数: 此方法不接受任何参数。

返回值: 此方法返回一个int值，它是通过take()获得的等待LTQ头部的消费者数量。

示例: 下面的程序使用一个生产者和3个消费者。生产者发送3条消息。调用take()的消费者将接收最新的消息。因此，此程序的不同执行可能导致不同的消费者获取不同的消息。

// Java程序展示了LinkedTransferQueue
// getWaitingConsumerCount()方法。
  
import java.util.concurrent.*;
  
public class GFG {
  
    // 创建LinkedTransferQueue对象
    LinkedTransferQueue<Integer> LTQ
        = new LinkedTransferQueue<>();
  
    class Producer implements Runnable {
  
        @Override
        public void run()
        {
            for (int i = 0; i < 3; i++) {
                try {
                    System.out.println("生产者正在等待传输...");
  
                    //将0、1、2添加到LTQ中
                    LTQ.transfer(i);
                    System.out.println("生产者传输元素：" + i);
  
                    //在生产者传输元素后显示等待使用者数量
                    System.out.println("传输后等待的使用者计数："
                                              + LTQ
                                                .getWaitingConsumerCount());
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
  
    class Consumer implements Runnable {
        int id;
        Consumer(int id)
        {
            this.id = id;
        }
  
        @Override
        public void run()
        {
            try {
                System.out.println("使用者" + id
                                   + "正在等待获取元素...");
  
                //在使用者获取LTQ中的元素之前显示等待使用者数量
                System.out.println("获取前等待的使用者计数："
                                   + LTQ
                                         .getWaitingConsumerCount());
  
                Integer s = LTQ.take();
                System.out.println("使用者" + id
                                   + "已接收元素：" + s);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
  
    public static void main(String[] args) throws InterruptedException
    {
        // class object to keep common LTQ for all consumers
        //(alternative: LTQ can be declared static)
        GFG obj = new GFG();
  
        // enabling multiple threads
        ExecutorService exService
            = Executors.newFixedThreadPool(3);
  
        // declare one producer and 3 consumers
        Producer producer = obj.new Producer();
        Consumer consumer0 = obj.new Consumer(0);
        Consumer consumer1 = obj.new Consumer(1);
        Consumer consumer2 = obj.new Consumer(2);
  
        // start producer and consumers
        exService.execute(producer);
        exService.execute(consumer0);
        exService.execute(consumer1);
        exService.execute(consumer2);
  
        // stop
        exService.shutdown();
    }
}

输出:

LinkedTransferQueue getWaitingConsumerCount()方法在Java中的示例