When consuming values from a Queue in an infinite loop -- what would be more efficient:
1) Blocking on the Queue until a value is available via take()
while (value = queue.take()) { doSomething(value); }
2) Sleeping for n milliseconds and checking if an item is available
while (true) {
if ((value = queue.poll()) != null) { doSomething(value); }
Thread.sleep(1000);
}
BlockingQueue implementations are thread-safe. All queuing methods achieve their effects atomically using internal locks or other forms of concurrency control.
BlockingQueue is a java Queue that support operations that wait for the queue to become non-empty when retrieving and removing an element, and wait for space to become available in the queue when adding an element.
A blocking queue is a queue which provides insert and remove operations that block or keep waiting until they are performed. The blocking queues are usually used in Producer-Consumer frameworks. This interface extends Queue and exists since Java 5. Null elements are not allowed.
Blocking is likely more efficient. In the background, the thread that initially calls take()
goes to sleep if there is no element available, letting other threads do whatever they need to do. The methods that add elements to the Queue will then wake up waiting threads when an element is added, so minimal time is spent checking the queue over and over again for whether an element is available.
Be careful when you use take()
. If you are using take()
from a service and service has db connection.
If take()
is returned after stale connection time out period then it will throw Stale connection exception.
Use poll for predefined waiting time and add null check for returned object.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With