Java for Beginner

Утренний анекдот🫣

https://t.me/Java_for_beginner_dev

#Mems

1.3K viewsДен, 01:02

Всем привет!
(Установка активированной 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

4.4K viewsДен, edited 02:47

Java for Beginner

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

02:56

Java for Beginner

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

Baeldung

A Guide to Java SynchronousQueue | Baeldung

Learn how you can utilize Java's SynchronousQueue to help you coordinate the work of multiple threads.

938 viewsДен, 05:32

Java for Beginner

Варианты ответа:

Anonymous Quiz

20%

Программа зациклится и ничего не выведет

20%

1, 2, 3

40%

Программа завершится с исключением InterruptedException

20%

Вывод не определен, так как порядок выполнения потоков не гарантирован

5 voters468 viewsДен, 08:48

Java for Beginner

Что выведет код?

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

401 viewsДен, 08:48

Java for Beginner

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

https://t.me/Java_for_beginner_dev

#Mems

347 viewsДен, 10:48

Java for Beginner

Основные методы 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

313 viewsДен, 14:34

Java for Beginner

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

Baeldung

Guide to the Java TransferQueue | Baeldung

Learn how the Java's TransferQueue can help you in writing multithreaded applications.

362 viewsДен, 05:43

Java for Beginner

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

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

Ждем каждого!

327 viewsДен, edited 06:20

Java for Beginner

Что выведет код?

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

336 viewsДен, 08:48

Java for Beginner

Варианты ответа:

Anonymous Quiz

Consumer 1: A, Consumer 1: B, Consumer 1: C

25%

Consumer 2: A, Consumer 2: B, Consumer 2: C

50%

Вывод не определен, так как порядок выполнения потоков не гарантирован

25%

Программа завершится с исключением InterruptedException

4 voters359 viewsДен, 08:48

Java for Beginner

#Mems

330 viewsАндрей, 10:38

Java for Beginner

А вы знали?🫢😂

https://t.me/Java_for_beginner_dev

#Mems

266 viewsДен, 10:45

Java for Beginner

Сегодня в 18:00 по МСК, @Alexander_Gors расскажет и покажет как решать задачи на Codewar! 😎 Присоединяйтесь будет интересно!!! Ждем каждого!

Встреча перенесена на 19:00!!! По техническим причинам!)

243 viewsДен, 11:10

Java for Beginner

Основные методы 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

243 viewsДен, 14:10

Java for Beginner

Пример использования методов tryTransfer и poll с тайм-аутами.

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

Использование LinkedTransferQueue для синхронизации потоков, обеспечивая передачу сигналов между ними.

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

#Java #Training #Medium #LinkedTransferQueue

212 viewsДен, 14:10

Java for Beginner

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

Те кто хочет поболтать вне темы до записи в 19:00 , можете присоединяться по ссылке: https://telemost.yandex.ru/j/45504529681360

telemost.yandex.ru

Яндекс.Телемост

Видеовстречи по ссылке. Собирайте в Телемосте рабочие конференции или встречайтесь с друзьями. Встречи не ограничены по времени. Можно скачать Телемост для Windows или macOS.

252 viewsАлександр Горских, 15:38

Java for Beginner

Live stream finished (7 days)

18:01

Java for Beginner

#Mems

234 viewsАлександр Горских, 18:48

Java for Beginner

PriorityBlockingQueue, особенности и внутреннее устройство

PriorityBlockingQueue — это реализация интерфейса BlockingQueue в Java, который поддерживает элементы с приоритетом. Очередь использует естественный порядок элементов или компаратор для их упорядочивания. В отличие от обычной очереди, в которой элементы обрабатываются в порядке их вставки, PriorityBlockingQueue позволяет извлекать элементы в соответствии с их приоритетами.

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

Приоритетный порядок:
Элементы в очереди сортируются по их естественному порядку или по заданному компаратору.
Высокоприоритетные элементы будут извлекаться первыми.

Неблокирующие операции вставки:
Методы put и offer не блокируются, так как очередь не имеет ограничений на размер.

Блокирующие операции извлечения:
Методы take и poll блокируются, если очередь пуста, до тех пор, пока элемент не станет доступным.

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

Без ограничения размера:
Очередь динамически расширяется по мере необходимости и не имеет фиксированного размера.

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

Базовая структура данных:
Основой PriorityBlockingQueue является массив, который представляет собой бинарную кучу (минимальную кучу).
Бинарная куча — это полное бинарное дерево, где каждый узел меньше или равен своим потомкам (для минимальной кучи).

Синхронизация:
Очередь использует методы синхронизации для обеспечения потокобезопасности.
Основные операции, такие как вставка и удаление элементов, синхронизированы для предотвращения гонок.

Алгоритмы вставки и извлечения:

При вставке нового элемента, он добавляется в конец массива, а затем "плавает вверх" по дереву, чтобы найти свое правильное место.
При извлечении элемента, корневой элемент (с минимальным значением) удаляется, и последний элемент массива перемещается на его место, затем "тонет" вниз, чтобы восстановить свойства кучи.

Пример кода внутреннего устройства

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

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

#Java #Training #Medium #PriorityBlockingQueue

for-each.dev

Руководство по PriorityBlockingQueue в Java | for-each.dev

Введение в Java's PriorityBlockingQueue с примерами использования

259 viewsДен, 05:27

About

Blog

Apps

Platform