import java.util.concurrent.LinkedBlockingQueue;

public class LinkedBlockingQueueChallenge {
    public static void main(String[] args) throws InterruptedException {
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.put(i);
        }

        int result = 0;
        while (!queue.isEmpty()) {
            result += queue.take();
            if (!queue.isEmpty()) {
                queue.put(queue.take() * 2);
            }
        }

        System.out.println("Result: " + result);
    }
}

LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(2);
queue.put(1);
queue.put(2);

Integer item = queue.take();
System.out.println(item);

boolean added = queue.offer(3);
System.out.println(added); // false, если очередь заполнена

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

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

int capacity = queue.remainingCapacity();
System.out.println(capacity);

List<Integer> list = new ArrayList<>();
queue.drainTo(list);
System.out.println(list);

queue.clear();

import java.util.concurrent.LinkedBlockingQueue;

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

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

        // Потребитель
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

import java.util.concurrent.LinkedBlockingQueue;

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

        // Запуск потока исполнителя задач
        new Thread(() -> {
            while (true) {
                try {
                    Runnable task = taskQueue.take();
                    task.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();

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

private static class Node<E> {
    volatile E item;
    volatile Node<E> next;

    Node(E item) {
        this.item = item;
    }
}

private transient volatile Node<E> head;
private transient volatile Node<E> tail;

public boolean offer(E e) {
    final Node<E> newNode = new Node<>(e);
    for (Node<E> t = tail, p = t; ; ) {
        Node<E> q = p.next;
        if (q == null) {
            if (p.next = q) {
                tail = newNode;
                return true;
            }
        } else {
            p = (t != tail) ? tail : q;
        }
    }
}

import java.util.concurrent.ConcurrentLinkedQueue;

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

        // Вставка элементов
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        // Извлечение элементов
        System.out.println(queue.poll()); // 1
        System.out.println(queue.poll()); // 2
        System.out.println(queue.poll()); // 3
    }
}

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.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 elapsedTime = System.currentTimeMillis() - creationTime;
        return unit.convert(delayTime - elapsedTime, TimeUnit.MILLISECONDS);
    }

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

private final transient ReentrantLock lock = new ReentrantLock();
private final Condition available = lock.newCondition();

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            E first = q.peek();
            if (first == null) {
                available.await();
            } else {
                long delay = first.getDelay(TimeUnit.NANOSECONDS);
                if (delay <= 0) {
                    return q.poll();
                }
                first = null;
                available.awaitNanos(delay);
            }
        }
    } finally {
        lock.unlock();
    }
}

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);
        }
    }
}