Java for Beginner
@Java_for_beginner_dev
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
About
Blog
Apps
Platform
Join
Java for Beginner
675 subscribers
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Ден, 
Java for Beginner
Сегодня в 18:00 по МСК, @Alexander_Gors расскажет и покажет как решать задачи на Codewar! 😎

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

Ждем каждого!
327 viewsДен, edited  
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
337 viewsДен, 
Java for Beginner
Варианты ответа:
Anonymous Quiz
0%
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Ден, 
Java for Beginner
#Mems
330 viewsАндрей, 
Java for Beginner
А вы знали?🫢😂

https://t.me/Java_for_beginner_dev

#Mems
266 viewsДен, 
Java for Beginner
Java for Beginner
Сегодня в 18:00 по МСК, @Alexander_Gors расскажет и покажет как решать задачи на Codewar! 😎 Присоединяйтесь будет интересно!!! Ждем каждого!
Встреча перенесена на 19:00!!! По техническим причинам!)
243 viewsДен, 
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Ден, 
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Ден, 
Java for Beginner
Встреча создана.
Сегодня мы будем вгрызаться в алгоритмические задачи и побеждать их. Стоит отметить что подготовленная задача только одна, а остальные будут попадаться случайно.

Те кто хочет поболтать вне темы до записи в 19:00 , можете присоединяться по ссылке: https://telemost.yandex.ru/j/45504529681360
telemost.yandex.ru
Яндекс.Телемост
Видеовстречи по ссылке. Собирайте в Телемосте рабочие конференции или встречайтесь с друзьями. Встречи не ограничены по времени. Можно скачать Телемост для Windows или macOS.
252 viewsАлександр Горских, 
Java for Beginner
Live stream finished (7 days)
Java for Beginner
#Mems
234 viewsАлександр Горских, 
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Ден, 
Java for Beginner
Как Вы попали к нам на канал?
Anonymous Poll
25%
с Youtube
7%
с Rutube
29%
с сайта JavaRush
18%
с других каналов Telegram
14%
знакомый посоветовал)))
4%
сам нашел по тегам
4%
напишу в комментариях!
28 voters218 viewsДен, 
Java for Beginner
Что выведет код?

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


#Tasks
220 viewsДен, 
Java for Beginner
Варианты ответа:
Anonymous Quiz
50%
Consumed: 5, Consumed: 10, Consumed: 20, Remaining: 15, Remaining: 30
25%
Consumed: 10, Consumed: 20, Consumed: 30, Remaining: 5, Remaining: 15
25%
Consumed: 5, Consumed: 10, Consumed: 15, Remaining: 20, Remaining: 30
0%
Consumed: 5, Consumed: 15, Consumed: 10, Remaining: 20, Remaining: 30
4 voters211 viewsДен, 
Java for Beginner
А потом он уходит с проекта и все радуются (охуевают)🤦‍♂️🤪😂

https://t.me/Java_for_beginner_dev

#Mems
224 viewsДен, 
Java for Beginner
Основные методы PriorityBlockingQueue и примеры использования

put(E e):

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


offer(E e):

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


take():

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


poll(long timeout, TimeUnit unit):

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


peek():

Возвращает элемент с наивысшим приоритетом, но не удаляет его из очереди. Возвращает null, если очередь пуста.
Integer peekedElement = queue.peek(); // Просмотр элемента без его удаления


size():

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


contains(Object o):

Проверяет, содержится ли указанный элемент в очереди.
boolean contains = queue.contains(15); // Проверка наличия элемента в очереди


remove(Object o):

Удаляет указанное значение из очереди, если оно присутствует.
boolean removed = queue.remove(25); // Удаление элемента из очереди


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

Обработка задач с приоритетами:

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


#Java #Training #Medium #PriorityBlockingQueue
219 viewsДен, 
Java for Beginner
Всем доброго субботнего утра!

У кого какие планы?)

Пет проекты двигаются?)))
176 viewsДен, edited  
Java for Beginner
Кстати, если у кого вдруг, совершенно случайно, есть премиум, проголосуйте за канал, можно темы поменять да исчо по мелочи))))

Заранее спасибо! 🙏
172 viewsДен, 
Java for Beginner
Всем доброго утра!

Напоминаю, что сегодня в 16:00 по МСК мы вновь встречаемся на лайф-кодинге и будем изучать поведенческие паттерны проектирования!🫡

Приходите, покодим вместе)😉
174 views