Java for Beginner
675 subscribers
548 photos
155 videos
12 files
839 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
DelayQueue, внутреннее устройство и преимущества

DelayQueue — это специализированная очередь из пакета java.util.concurrent, которая предназначена для хранения элементов до истечения их задержки. Она основана на приоритетной очереди и используется в ситуациях, где необходимо реализовать задержку выполнения задач.

Внутреннее устройство DelayQueue

DelayQueue реализует интерфейсы BlockingQueue и Queue. Она состоит из элементов, которые должны реализовать интерфейс Delayed. Этот интерфейс требует реализации метода getDelay(TimeUnit unit), который возвращает оставшееся время задержки элемента в указанных единицах.

Элементы DelayQueue:

Каждый элемент в DelayQueue должен реализовать интерфейс Delayed.
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;
}
}


Внутренняя структура:

DelayQueue использует приоритетную очередь для хранения элементов. Это позволяет эффективно управлять элементами на основе их времени задержки.
Приоритетная очередь реализуется на основе кучи (heap), что обеспечивает логарифмическое время выполнения операций вставки и удаления.


Механизм блокировки:

DelayQueue использует методы ReentrantLock для обеспечения потокобезопасности. Это позволяет избежать гонок и обеспечивает корректное поведение в многопоточной среде.

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


Извлечение элементов:

При попытке извлечения элемента из DelayQueue, если задержка элемента еще не истекла, поток будет заблокирован до истечения задержки.
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();
}
}


Преимущества DelayQueue

Управление задержками: DelayQueue идеально подходит для задач, где необходимо управлять задержками, таких как планирование задач или кэширование с истечением времени.
Потокобезопасность: Использование механизмов блокировки и приоритетной очереди обеспечивает безопасность в многопоточных приложениях.
Гибкость: Возможность использовать любые объекты, реализующие интерфейс Delayed, позволяет легко адаптировать DelayQueue под различные задачи.


Ссылки на полезные статьи (спасибо авторам за проделанную работу) :
https://www.baeldung.com/java-delay-queue
https://habr.com/ru/articles/599603/

#Java #Training #Medium #DelayQueue
Варианты ответа:
Anonymous Quiz
0%
3
33%
4
67%
6
0%
9
Что выведет код?

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


#Tasks
Среди вас есть кто видел его вживую?🧐

https://t.me/Java_for_beginner_dev

#Mems
Основные методы DelayQueue и примеры использования

add(E e):

Добавляет элемент в очередь. Если очередь полна, генерируется исключение.
DelayQueue<DelayedElement> delayQueue = new DelayQueue<>();
delayQueue.add(new DelayedElement(1000));


put(E e):

Добавляет элемент в очередь. Если очередь полна, операция блокируется до освобождения места.
delayQueue.put(new DelayedElement(2000));


offer(E e):

Добавляет элемент в очередь, если это возможно. Возвращает true, если элемент был добавлен, и false в противном случае.
boolean added = delayQueue.offer(new DelayedElement(3000));


take():

Извлекает и удаляет элемент из головы очереди, ожидая при необходимости до истечения задержки.
DelayedElement element = delayQueue.take();


poll(long timeout, TimeUnit unit):

Извлекает и удаляет элемент из головы очереди, ожидая до указанного времени, если необходимо.
DelayedElement element = delayQueue.poll(2, TimeUnit.SECONDS);


clear():

Удаляет все элементы из очереди.
delayQueue.clear();


remove(Object o):

Удаляет указанный элемент из очереди, если он присутствует.
delayQueue.remove(someElement);


Примеры использования

Запланированные задачи:
DelayQueue можно использовать для планирования выполнения задач через определенные промежутки времени.
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);
}
}
}


Кэширование с истечением срока действия:

DelayQueue можно использовать для реализации кэша, элементы которого удаляются по истечении определенного времени.
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);
}
}
}

#Java #Training #Medium #DelayQueue
Утренний анекдот🫣

https://t.me/Java_for_beginner_dev

#Mems
Всем привет!
(Установка активированной IntelliJ IDEA ideaIU-2024.2.0.1 Ulimate)

В связи с тем, что при отсоединении чата от канала, потерлись комментарии всех ранее опубликованных постов, вновь запилю гайд по установке взломанной версии IntelliJ IDEA Ulimate, да и всех остальных продуктов JetBrains заодно. (которые не хотят взаимодействовать с программистами из России 😡).

Итак:
1. Качаем с официального сайта
https://www.jetbrains.com/ версию того продукта который вам нужен. Я использовал новейшую IntelliJ IDEA ideaIU-2024.2.0.1 (на момент написания поста), поэтому приложу ее к посту. (Кому-то может понадобиться VPN).
2. Качаем, приложенный в комментариях архив
jetbra.zip
3. Распаковываем
jetbra.zip в нужное вам место на Вашем компуктере, переходим в папку scripts и выполняем нужный скрипт и ждем окончания его работы (окошечко с кнопкой done):
- install-current-user.vbs — для текущего пользователя Windows
- install-all-users.vbs — для всех пользователей Windows
-
install.sh — для MacOS и Linux
4. В папке расположения продукта (обычно такой путь - C:\Program Files\JetBrains\IntelliJ IDEA 2024.2.0.1\bin) находим файл idea64.exe.vmoptions и в нем проверяем наличие строки:
-javaagent:C:\jetbra\ja-netfilter.jar=jetbrains. Если ее нет, дописываем ручками! (Внимательно проверяйте путь, по которому у Вас находится распакованный архив jetbra.zip).
5. По выбору: из приложенного в комментариях файла получаем ключ (строго для IntelliJ IDEA), или переходим на сайт
https://3.jetbra.in, где в любом из активных хостов, выбираем необходимый для активации продукт и получаем в буфер ключ.
6. Запускаем продукт и переходим в вкладку Activation Code и вставляем скопированный ранее ключ.

Все! Ваш продукт активирован до 2026 года, что как я считаю более чем достаточно)))


Приятного использования и всем пожалуйста😉

#Installing_IDEA
Java for Beginner pinned «Всем привет! (Установка активированной IntelliJ IDEA ideaIU-2024.2.0.1 Ulimate) В связи с тем, что при отсоединении чата от канала, потерлись комментарии всех ранее опубликованных постов, вновь запилю гайд по установке взломанной версии IntelliJ IDEA Ulimate…»
SynchronousQueue

SynchronousQueue — это специализированная реализация интерфейса BlockingQueue, который позволяет передавать элементы между потоками напрямую. В отличие от других очередей, у SynchronousQueue нет внутреннего буфера или емкости. Каждый put-запрос должен соответствовать take-запросу, чтобы операция завершилась. Это делает SynchronousQueue полезной в ситуациях, когда требуется прямая передача данных между потоками.

Внутреннее устройство SynchronousQueue

SynchronousQueue можно представить как точку передачи данных, где один поток передает элемент, и другой поток немедленно его забирает. Если нет готового потребителя для передачи, операция будет заблокирована до тех пор, пока потребитель не появится.

Блокировка и синхронизация:

SynchronousQueue использует два режима передачи данных: "fair" (справедливый) и "non-fair" (несправедливый). В справедливом режиме потоки обслуживаются в порядке поступления (FIFO), тогда как в несправедливом режиме порядок не гарантируется.
Реализация на основе блокировки и синхронизации происходит с помощью ReentrantLock и Condition.


Режимы работы:

Fair Mode: Гарантирует обслуживание потоков в порядке поступления. Это достигается за счет использования очередей ожидания для операций put и take.
Non-Fair Mode: Потоки обслуживаются без строгого порядка, что может приводить к уменьшению времени ожидания для некоторых потоков, но не гарантирует равномерности.


Основные структуры данных:

В справедливом режиме используются две очереди ожидания для хранения ожидающих put и take операций.
В несправедливом режиме используется стек для выполнения операций.


Пример кода внутреннего устройства
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();
}
}


Особенности SynchronousQueue

Отсутствие буферизации: У SynchronousQueue нет внутреннего буфера, что означает, что каждое добавление элемента должно совпадать с извлечением.
Потокобезопасность: Очередь разработана с учетом многопоточности и обеспечивает высокую степень безопасности для работы в конкурентной среде.
Высокая скорость передачи данных: За счет отсутствия буферизации и немедленной передачи элементов достигается высокая скорость обмена данными между потоками.
Гибкость: Возможность выбора между справедливым и несправедливым режимами работы позволяет оптимизировать производительность в зависимости от конкретных требований.


Преимущества SynchronousQueue

Эффективность в межпоточном взаимодействии: SynchronousQueue идеально подходит для ситуаций, где требуется немедленная передача данных между потоками, например, для реализации паттерна "производитель-потребитель".
Простота реализации: Очередь предоставляет простой API для обмена данными между потоками, что упрощает разработку многопоточных приложений.
Высокая производительность: За счет минимального количества операций по синхронизации достигается высокая производительность при обмене данными.


Ссылки на полезные статьи (спасибо авторам за проделанную работу) :
https://www.baeldung.com/java-synchronous-queue

#Java #Training #Medium #SynchronousQueue
Что выведет код?

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


#Tasks
Прыгал бы с ноутбуком чтоле😂🤪

https://t.me/Java_for_beginner_dev

#Mems
Основные методы SynchronousQueue и примеры использования

put(E e):

Добавляет элемент в очередь. Если нет готового потребителя, операция блокируется до тех пор, пока потребитель не появится.
SynchronousQueue<Integer> queue = new SynchronousQueue<>();
queue.put(1); // блокируется до появления потребителя


take():

Извлекает и удаляет элемент из очереди. Если нет готового поставщика, операция блокируется до тех пор, пока элемент не будет добавлен.
Integer element = queue.take(); // блокируется до появления элемента


offer(E e, long timeout, TimeUnit unit):

Пытается добавить элемент в очередь в течение заданного времени ожидания. Возвращает true, если элемент был добавлен, и false в противном случае.

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


poll(long timeout, TimeUnit unit):

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


isEmpty():

Возвращает true, если очередь пуста.
boolean empty = queue.isEmpty();


size():

Возвращает количество элементов в очереди. В случае SynchronousQueue всегда возвращает 0 или 1.
int size = queue.size();


Примеры использования SynchronousQueue

Производитель-потребитель:
SynchronousQueue часто используется для реализации паттерна "производитель-потребитель", где производитель и потребитель обмениваются данными напрямую.
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();
}
}


Синхронизация потоков:
SynchronousQueue можно использовать для синхронизации потоков, обеспечивая передачу сигналов между ними.
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();
}
}


#Java #Training #Medium #SynchronousQueue
LinkedTransferQueue, особенности и внутреннее устройство

LinkedTransferQueue — это неблокирующая очередь с дополнительными функциями для передачи данных, основанная на алгоритмах немедленной передачи данных между потоками. Эта очередь является частью пакета java.util.concurrent и предоставляет высокопроизводительную реализацию интерфейса TransferQueue, который является подинтерфейсом BlockingQueue.

Особенности LinkedTransferQueue

Неблокирующая реализация: Основана на неблокирующих алгоритмах, что позволяет избежать блокировок при выполнении операций вставки и извлечения, обеспечивая высокую производительность.
Поддержка передачи данных (transfer): Помимо стандартных операций добавления и удаления элементов, LinkedTransferQueue поддерживает операцию передачи данных (transfer), которая блокируется до тех пор, пока элемент не будет получен другим потоком.
Высокая производительность в многопоточной среде: Благодаря неблокирующим алгоритмам, LinkedTransferQueue обеспечивает высокую производительность и масштабируемость в многопоточных приложениях.
Упорядоченность: Очередь гарантирует упорядоченность элементов по принципу FIFO (First-In-First-Out).

Внутреннее устройство LinkedTransferQueue

Структура данных:
Основой очереди является односвязный список узлов, где каждый узел содержит элемент и ссылку на следующий узел.
Узлы могут быть двух типов: данные (data nodes) и запросы (request nodes). Узлы данных содержат элементы, а запросы — нет.


Алгоритмы и синхронизация:
Используется алгоритм CAS (Compare-And-Swap) для обеспечения атомарности операций и предотвращения блокировок.
При вставке элемента создается новый узел данных и пытается добавить его в конец очереди.
При извлечении элемента очередь ищет узел данных и удаляет его.


Операция передачи данных (transfer):
При вызове метода transfer, элемент добавляется в очередь и операция блокируется до тех пор, пока элемент не будет извлечен другим потоком.
Это достигается за счет специального состояния узлов и механизма ожидания/оповещения потоков.


Пример кода внутреннего устройства
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();
}
}


Ссылки на полезные статьи (спасибо авторам за проделанную работу) :
https://www.baeldung.com/java-transfer-queue
https://for-each.dev/lessons/b/-java-transfer-queue/

#Java #Training #Medium #LinkedTransferQueue
Сегодня в 18:00 по МСК, @Alexander_Gors расскажет и покажет как решать задачи на Codewar! 😎

Присоединяйтесь будет интересно!!!

Ждем каждого!
Что выведет код?

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


Внимание! Задача с подвохом, внимательнее)))

#Tasks
А вы знали?🫢😂

https://t.me/Java_for_beginner_dev

#Mems
Основные методы LinkedTransferQueue и примеры использования

put(E e):

Вставляет элемент в очередь. Этот метод никогда не блокируется в LinkedTransferQueue, так как очередь не имеет ограничений на размер.
TransferQueue<Integer> queue = new LinkedTransferQueue<>();
queue.put(1); // Вставка элемента в очередь


offer(E e):

Вставляет элемент в очередь, возвращает true, если элемент был успешно вставлен.
boolean success = queue.offer(2); // Вставка элемента, возвращает true


transfer(E e):

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


tryTransfer(E e):

Пытается вставить элемент в очередь, не блокируя, если нет ожидающего потребителя. Возвращает true, если элемент был передан.
boolean transferred = queue.tryTransfer(4); // Пытается передать элемент, не блокируя


tryTransfer(E e, long timeout, TimeUnit unit):

Пытается передать элемент, блокируясь в течение указанного времени ожидания, если нет готового потребителя. Возвращает true, если элемент был передан.
boolean transferredWithTimeout = queue.tryTransfer(5, 1, TimeUnit.SECONDS); // Пытается передать элемент с тайм-аутом


take():

Извлекает и удаляет элемент из головы очереди, блокируясь до тех пор, пока элемент не станет доступен.
Integer element = queue.take(); // Блокирующее извлечение элемента


poll(long timeout, TimeUnit unit):

Пытается извлечь элемент из головы очереди, блокируясь в течение указанного времени ожидания. Возвращает элемент или null, если тайм-аут истек.
Integer polledElement = queue.poll(1, TimeUnit.SECONDS); // Пытается извлечь элемент с тайм-аутом


remainingCapacity():

Возвращает оставшуюся емкость очереди. Для LinkedTransferQueue всегда возвращает Integer.MAX_VALUE.
int capacity = queue.remainingCapacity(); // Возвращает Integer.MAX_VALUE


hasWaitingConsumer():

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


getWaitingConsumerCount():

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


Примеры использования LinkedTransferQueue

Производитель-потребитель с передачей данных:
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();
}
}


#Java #Training #Medium #LinkedTransferQueue