LinkedTransferQueue hasWaitingConsumer() method in Java

The Java.util.concurrent.LinkedTransferQueue.hasWaitingConsumer() method always returns true if there is at least one consumer in the queue waiting to receive an element via BlockingQueue.take() or timed poll. The returned value represents a momentary state of affairs.

Syntax

public boolean hasWaitingConsumer()

Parameters: It does not take in any parameter.

Return Value: This method returns a boolean value which is true if at least one consumer is present in the queue.

Below are a few examples to illustrate the LinkedTransferQueue.hasWaitingConsumer() method:

Example 1:

// Java code to demonstrate 
// hasWaitingConsumer() method 
  
import java.util.concurrent.LinkedTransferQueue; 
  
class GFG { 
    public static void main(String args[]) 
    { 
        LinkedTransferQueue<String> LTQ 
            = new LinkedTransferQueue<String>(); 
  
        LTQ.add("Geeks"); 
        LTQ.add("For"); 
        LTQ.add("Geeks"); 
        LTQ.add("GeeksForGeeks"); 
  
        System.out.println(LTQ.hasWaitingConsumer()); 
    } 
} 

Output:

false

Example 2:

// Java code to demonstrate 
// hasWaitingConsumer() method 
  
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.LinkedTransferQueue; 
  
public class GFG { 
  
    LinkedTransferQueue<Integer> LTQ 
        = new LinkedTransferQueue<>(); 
  
    class LTQProducer implements Runnable { 
  
        @Override
        public void run() 
        { 
            for (int i = 0; i < 3; i++) { 
                try { 
                    System.out.println("Producer is"
                                       + " waiting to transfer"); 
                    LTQ.transfer(i); 
                    System.out.println("Producer transferred"
                                       + " element: "
                                       + i); 
                    System.out.println("Is there any consumer"
                                       + " still waiting to"
                                       + " receive an element"
                                       + " after transfer -> "
                                       + LTQ.hasWaitingConsumer()); 
                } 
                catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
        } 
    } 
  
    class LTQConsumer implements Runnable { 
        int id; 
        LTQConsumer(int id) 
        { 
            this.id = id; 
        } 
  
        @Override
        public void run() 
        { 
            try { 
                System.out.println("Consumer "
                                   + id 
                                   + " is waiting to "
                                   + "take an element."); 
                System.out.println("Is there any consumer"
                                   + " still waiting to"
                                   + " receive an element"
                                   + " after transfer -> "
                                   + LTQ.hasWaitingConsumer()); 
                Integer s = LTQ.take(); 
                System.out.println("Consumer "
                                   + id 
                                   + " received Element: "
                                   + s); 
            } 
            catch (InterruptedException e) { 
                System.out.println(e); 
            } 
        } 
    } 
  
    // Driver code 
    public static void main(String[] args) 
        throws InterruptedException 
    { 
        GFG ob = new GFG(); 
  
        ExecutorService exService 
            = Executors.newFixedThreadPool(3); 
  
        LTQProducer p = ob.new LTQProducer(); 
        LTQConsumer c1 = ob.new LTQConsumer(0); 
        LTQConsumer c2 = ob.new LTQConsumer(1); 
  
        exService.execute(p); 
        exService.execute(c1); 
        exService.execute(c2); 
  
        exService.shutdown(); 
    } 
} 

Output:

Producer is waiting to transfer
Consumer 0 is waiting to take an element.
Is there any consumer waiting to take an element -> false
Consumer 1 is waiting to take an element.
Is there any consumer waiting to take an element -> false
Consumer 0 received Element: 0
Producer transferred element: 0
Is there any consumer still waiting to receive an element after transfer -> true
Producer is waiting to transfer
Producer transferred element: 1
Consumer 1 received Element: 1
Is there any consumer still waiting to receive an element after transfer -> false
Producer is waiting to transfer

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended Posts: