import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueChallenge {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        for (int i = 1; i <= 5; i++) {
            queue.offer(i);
        }

        int result = 1;
        for (int i = 0; i < 3; i++) {
            Integer val = queue.poll();
            if (val != null) {
                result *= val;
            }
            queue.offer(result);
        }

        int sum = 0;
        for (Integer val : queue) {
            sum += val;
        }

        System.out.println("Sum: " + sum);
    }
}

ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
queue.offer(1);
queue.offer(2);

Integer item = queue.poll();
System.out.println(item); // 1

Integer item = queue.peek();
System.out.println(item); // 2

boolean isEmpty = queue.isEmpty();
System.out.println(isEmpty); // false

int size = queue.size();
System.out.println(size); // 1

import java.util.concurrent.ConcurrentLinkedQueue;

public class ProducerConsumerExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();

        // Производитель
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                queue.offer(i);
                System.out.println("Produced: " + i);
            }
        }).start();

        // Потребитель
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                Integer item;
                while ((item = queue.poll()) == null) {
                    // Ожидание элемента
                }
                System.out.println("Consumed: " + item);
            }
        }).start();
    }
}

import java.util.concurrent.ConcurrentLinkedQueue;

public class TaskQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Runnable> taskQueue = new ConcurrentLinkedQueue<>();

        // Запуск потока исполнителя задач
        new Thread(() -> {
            while (true) {
                Runnable task = taskQueue.poll();
                if (task != null) {
                    task.run();
                }
            }
        }).start();

        // Добавление задач в очередь
        taskQueue.offer(() -> System.out.println("Task 1 executed"));
        taskQueue.offer(() -> System.out.println("Task 2 executed"));
    }
}

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

class DelayedElement implements Delayed {
    private final long delayTime;
    private final long creationTime;

    public DelayedElement(long delayTime) {
        this.delayTime = delayTime;
        this.creationTime = System.currentTimeMillis();
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long diff = creationTime + delayTime - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS));
    }

    @Override
    public String toString() {
        return "DelayedElement{" + "delayTime=" + delayTime + '}';
    }
}

public class DelayQueueChallenge {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedElement> queue = new DelayQueue<>();
        queue.offer(new DelayedElement(1000));
        queue.offer(new DelayedElement(2000));
        queue.offer(new DelayedElement(3000));

        long startTime = System.currentTimeMillis();

        int sum = 0;
        for (int i = 0; i < 3; i++) {
            DelayedElement element = queue.take();
            long elapsedTime = (System.currentTimeMillis() - startTime) / 1000;
            sum += elapsedTime;
            System.out.println("Taken: " + element + " at " + elapsedTime + " seconds");
        }

        System.out.println("Sum: " + sum);
    }
}

DelayQueue<DelayedElement> delayQueue = new DelayQueue<>();
delayQueue.add(new DelayedElement(1000));

delayQueue.put(new DelayedElement(2000));

boolean added = delayQueue.offer(new DelayedElement(3000));

DelayedElement element = delayQueue.take();

DelayedElement element = delayQueue.poll(2, TimeUnit.SECONDS);

delayQueue.clear();

delayQueue.remove(someElement);

import java.util.concurrent.DelayQueue;

public class ScheduledTaskExample {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedElement> delayQueue = new DelayQueue<>();

        // Добавление задач
        delayQueue.put(new DelayedElement(3000)); // 3 секунды задержки
        delayQueue.put(new DelayedElement(5000)); // 5 секунд задержки

        // Обработка задач
        while (!delayQueue.isEmpty()) {
            DelayedElement element = delayQueue.take();
            System.out.println("Task executed: " + element);
        }
    }
}

import java.util.concurrent.DelayQueue;

public class CacheExample {
    private static class CacheItem implements Delayed {
        private final String value;
        private final long expiryTime;

        public CacheItem(String value, long delay) {
            this.value = value;
            this.expiryTime = System.currentTimeMillis() + delay;
        }

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

        @Override
        public int compareTo(Delayed o) {
            if (this.expiryTime < ((CacheItem) o).expiryTime) {
                return -1;
            }
            if (this.expiryTime > ((CacheItem) o).expiryTime) {
                return 1;
            }
            return 0;
        }

        @Override
        public String toString() {
            return value;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DelayQueue<CacheItem> cache = new DelayQueue<>();

        // Добавление элементов в кэш
        cache.put(new CacheItem("Item1", 2000)); // 2 секунды жизни
        cache.put(new CacheItem("Item2", 4000)); // 4 секунды жизни

        // Извлечение элементов по истечении срока жизни
        while (!cache.isEmpty()) {
            CacheItem item = cache.take();
            System.out.println("Expired item: " + item);
        }
    }
}