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

TransferQueue<Integer> queue = new LinkedTransferQueue<>();
queue.put(1); // Вставка элемента в очередь

boolean success = queue.offer(2); // Вставка элемента, возвращает true

queue.transfer(3); // Вставка элемента и блокировка до его извлечения

boolean transferred = queue.tryTransfer(4); // Пытается передать элемент, не блокируя

boolean transferredWithTimeout = queue.tryTransfer(5, 1, TimeUnit.SECONDS); // Пытается передать элемент с тайм-аутом

Integer element = queue.take(); // Блокирующее извлечение элемента

Integer polledElement = queue.poll(1, TimeUnit.SECONDS); // Пытается извлечь элемент с тайм-аутом

int capacity = queue.remainingCapacity(); // Возвращает Integer.MAX_VALUE

boolean hasConsumers = queue.hasWaitingConsumer(); // Проверяет наличие ожидающих потребителей

int consumerCount = queue.getWaitingConsumerCount(); // Возвращает количество ожидающих потребителей

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

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

        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Produced: " + i);
                    queue.transfer(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.LinkedTransferQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TransferQueue;

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

        new Thread(() -> {
            try {
                boolean transferred = queue.tryTransfer(1, 1, TimeUnit.SECONDS);
                if (transferred) {
                    System.out.println("Element transferred");
                } else {
                    System.out.println("Failed to transfer element");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        new Thread(() -> {
            try {
                Integer element = queue.poll(2, TimeUnit.SECONDS);
                if (element != null) {
                    System.out.println("Element retrieved: " + element);
                } else {
                    System.out.println("No element retrieved");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

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

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

        Thread thread1 = new Thread(() -> {
            try {
                queue.transfer("Signal from Thread 1");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                String signal = queue.take();
                System.out.println("Received: " + signal);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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