The java.util.concurrent.DelayQueue class in an implementation of the BlockingQueue interface. Elements added to the queue must implement the java.util.concurrent.Delayed interface.
The queue is unbound in size, enabling adds to return immediately, we can only take an element from the queue when the delay time has expired. If multiple elements have expired delays, the element with the longest delay expiration will be taken first.
package org.kodejava.util.concurrent;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
public class DelayQueueExample {
public static void main(String[] args) {
// Creates an instance of blocking queue using the DelayQueue.
final BlockingQueue<DelayObject> queue = new DelayQueue<>();
final Random random = new Random();
new Thread(() -> {
while (true) {
try {
// Put some Delayed object into the Queue.
int delay = random.nextInt(10000);
DelayObject object = new DelayObject(
UUID.randomUUID().toString(), delay);
System.out.printf("Put object = %s%n", object);
queue.put(object);
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Producer Thread").start();
new Thread(() -> {
while (true) {
try {
// Take elements out from the DelayQueue object.
DelayObject object = queue.take();
System.out.printf("[%s] - Take object = %s%n",
Thread.currentThread().getName(), object);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Consumer Thread-1").start();
new Thread(() -> {
while (true) {
try {
// Take elements out from the DelayQueue object.
DelayObject object = queue.take();
System.out.printf("[%s] - Take object = %s%n",
Thread.currentThread().getName(), object);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Consumer Thread-2").start();
}
}
Below is an implementation of the Delayed interface. In the implementation class we have to implement the getDelay(TimeUnit) and the compareTo(Object) methods.
package org.kodejava.util.concurrent;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
public class DelayObject implements Delayed {
private final String data;
private final long startTime;
public DelayObject(String data, long delay) {
this.data = data;
this.startTime = System.currentTimeMillis() + delay;
}
@Override
public long getDelay(TimeUnit unit) {
long diff = startTime - System.currentTimeMillis();
return unit.convert(diff, TimeUnit.MILLISECONDS);
}
@Override
public int compareTo(Delayed o) {
return Long.compare(this.startTime, ((DelayObject) o).startTime);
}
@Override
public String toString() {
return "{" +
"data='" + data + '\'' +
", startTime=" + startTime +
'}';
}
}
Running this example give you some kind of the following output:
Put object = {data='ff217d8f-30c7-4ff6-b107-f5e6b13b5cf1', startTime=1635830327667}
Put object = {data='ad9b7f64-04f6-45ba-8b4a-6d9d25785303', startTime=1635830326742}
Put object = {data='7e439219-486a-473f-b093-2ada26b682f4', startTime=1635830328540}
Put object = {data='1fd6f3d2-60b1-4986-a8d0-ceb0863b30a7', startTime=1635830328498}
[Consumer Thread-1] - Take object = {data='ad9b7f64-04f6-45ba-8b4a-6d9d25785303', startTime=1635830326742}
Put object = {data='9d8811a2-5f2a-487b-a229-11ad8ed54515', startTime=1635830330952}
Put object = {data='baf72a83-0242-42cb-93db-9ef08da5f78d', startTime=1635830336088}
[Consumer Thread-2] - Take object = {data='ff217d8f-30c7-4ff6-b107-f5e6b13b5cf1', startTime=1635830327667}
Put object = {data='9d4d14c5-0777-4675-aa67-a49a0519d9b2', startTime=1635830328952}
Put object = {data='c4979d10-4a11-44a8-b79c-ff31309e968b', startTime=1635830331430}
