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 BlockingQueueMain {
    static BlockingQueue<String> queue = new LinkedBlockingDeque<>();

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
        new Thread(new Consumer()).start();
    }

    static class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 4; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + " start to put, time: " + LocalDateTime.now());
                    var value = "producer" + i;
                    queue.put(value);
                    System.out.println(Thread.currentThread().getName() + " put the value " + value + ", time: " + LocalDateTime.now());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 2; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + " start to take, time: " + LocalDateTime.now());
                    System.out.println(Thread.currentThread().getName() + " take the value " + queue.take() + ", time: " + LocalDateTime.now());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class CopyOnWriteArrayListMain {
    public static void main(String[] args) throws InterruptedException {
        var list = new CopyOnWriteArrayList<>(List.of("0"));

        var iterator = list.iterator();
        list.add("1");
        iterator.forEachRemaining(System.out::println);

        System.out.println(Arrays.toString(list.toArray()));
    }
}