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

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

public class SynchronousQueueExample {
    public static void main(String[] args) {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>(true); // fair mode

        Thread producer = new Thread(() -> {
            try {
                System.out.println("Putting element: 1");
                queue.put(1);
                System.out.println("Element 1 put");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                System.out.println("Taking element...");
                Integer element = queue.take();
                System.out.println("Element taken: " + element);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

import java.util.concurrent.*;

public class SynchronousQueueExample {

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

        Thread producer = new Thread(() -> {
            try {
                queue.put(1);
                queue.put(2);
                queue.put(3);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                System.out.println(queue.take());
                System.out.println(queue.take());
                System.out.println(queue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();

        try {
            producer.join();
            consumer.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

SynchronousQueue<Integer> queue = new SynchronousQueue<>();
queue.put(1); // блокируется до появления потребителя

Integer element = queue.take(); // блокируется до появления элемента

boolean success = queue.offer(1, 2, TimeUnit.SECONDS); // попытка добавить элемент в течение 2 секунд

Integer element = queue.poll(2, TimeUnit.SECONDS); // попытка извлечь элемент в течение 2 секунд

boolean empty = queue.isEmpty();

int size = queue.size();

import java.util.concurrent.SynchronousQueue;

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

        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Produced: " + i);
                    queue.put(i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

import java.util.concurrent.SynchronousQueue;

public class ThreadSyncExample {
    public static void main(String[] args) {
        SynchronousQueue<String> queue = new SynchronousQueue<>();

        Thread thread1 = new Thread(() -> {
            try {
                System.out.println("Thread 1 waiting for signal...");
                String signal = queue.take();
                System.out.println("Thread 1 received signal: " + signal);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
                queue.put("Start");
                System.out.println("Thread 2 sent signal");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        thread1.start();
        thread2.start();
    }
}

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;

public class LinkedTransferQueueExample {
    public static void main(String[] args) {
        TransferQueue<Integer> queue = new LinkedTransferQueue<>();

        Thread producer = new Thread(() -> {
            try {
                System.out.println("Producer: Transferring element 1");
                queue.transfer(1);
                System.out.println("Producer: Element 1 transferred");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                System.out.println("Consumer: Waiting to take element");
                Integer element = queue.take();
                System.out.println("Consumer: Taken element " + element);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

import java.util.concurrent.*;

public class LinkedTransferQueueAdvancedExample {

    public static void main(String[] args) {
        LinkedTransferQueue<String> queue = new LinkedTransferQueue<>();

        Thread producer = new Thread(() -> {
            try {
                queue.transfer("A");
                queue.transfer("B");
                queue.transfer("C");
                queue.transfer("D");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer1 = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    String item = queue.take();
                    if (item.equals("C")) {
                        Thread.currentThread().interrupt();
                    }
                    System.out.println("Consumer 1: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer2 = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    String item = queue.take();
                    if (item.equals("D")) {
                        Thread.currentThread().interrupt();
                    }
                    System.out.println("Consumer 2: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer1.start();
        consumer2.start();

        try {
            producer.join();
            consumer1.join();
            consumer2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}