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

import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        // Добавление элементов в очередь
        queue.put(10);
        queue.put(20);
        queue.put(5);

        // Извлечение элементов из очереди
        System.out.println(queue.take()); // 5
        System.out.println(queue.take()); // 10
        System.out.println(queue.take()); // 20
    }
}

import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueTask {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();
        
        queue.add(10);
        queue.add(30);
        queue.add(20);
        queue.add(5);
        queue.add(15);

        // Основная логика
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 3; i++) {
                    Integer value = queue.take();
                    System.out.println("Consumed: " + value);
                    Thread.sleep(50); // задержка для имитации обработки
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        consumer.start();
        consumer.join(); // Ожидаем завершения потока

        // Выводим оставшиеся элементы в очереди
        while (!queue.isEmpty()) {
            System.out.println("Remaining: " + queue.poll());
        }
    }
}

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

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

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

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

Integer peekedElement = queue.peek(); // Просмотр элемента без его удаления

int size = queue.size(); // Получение размера очереди

boolean contains = queue.contains(15); // Проверка наличия элемента в очереди

boolean removed = queue.remove(25); // Удаление элемента из очереди

import java.util.concurrent.PriorityBlockingQueue;

class Task implements Comparable<Task> {
    private int priority;
    private String name;

    public Task(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    @Override
    public int compareTo(Task other) {
        return Integer.compare(this.priority, other.priority);
    }

    @Override
    public String toString() {
        return "Task{name='" + name + "', priority=" + priority + '}';
    }
}

public class TaskScheduler {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Task> taskQueue = new PriorityBlockingQueue<>();

        taskQueue.put(new Task(3, "Low priority task"));
        taskQueue.put(new Task(1, "High priority task"));
        taskQueue.put(new Task(2, "Medium priority task"));

        while (!taskQueue.isEmpty()) {
            Task task = taskQueue.take();
            System.out.println("Processing " + task);
        }
    }
}