public class DelayQueueMain {
    public static void main(String[] args) {
        var queue = new DelayQueue<DelayedUser>();
        var executorService = Executors.newFixedThreadPool(2);

        executorService.execute(() -> {
            for (int i = 0; i < 3; i++) {
                var delayedUser = new DelayedUser("name-" + i, new Random().nextInt(2000));
                queue.put(delayedUser);
                System.out.println(Thread.currentThread().getName() + " put user: " + delayedUser.name() + ", avaibleTime: " + delayedUser.avaibleTime());
                sleep(1);
            }
        });

        executorService.execute(() -> {
            for (int i = 0; i < 3; i++) {
                try {
                    var delayedUser = queue.take();
                    System.out.println(Thread.currentThread().getName() + " take user: " + delayedUser.name() + ", avaibleTime: " + delayedUser.avaibleTime());
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        executorService.shutdown();
    }

    static void sleep(int seconds) {
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

record DelayedUser(String name, long avaibleTime) implements Delayed {

    DelayedUser(String name, long avaibleTime) {
        this.name = name;
        this.avaibleTime = System.currentTimeMillis() + avaibleTime;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(avaibleTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return (int) (this.avaibleTime - ((DelayedUser) o).avaibleTime);
    }
}

public class ForkJoinPoolMain {
    public static void main(String[] args) {
        var forkJoinPool = new ForkJoinPool();
        var sumTask = new SumTask(0, 100000000);
        forkJoinPool.submit(sumTask);
        
        System.out.println(sumTask.join());
    }
}

class SumTask extends RecursiveTask<Long> {
    private final static int TASK_THRESHOLD = 10000;
    private final int start;
    private final int end;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if (end - start < TASK_THRESHOLD) {
            return LongStream.range(start, end).sum();
        } else {
            int middle = start + (end - start) / 2;
            var sumTask1 = new SumTask(start, middle);
            var sumTask2 = new SumTask(middle, end);

            return sumTask1.fork().join() + sumTask2.fork().join();
        }
    }
}