⌨️ Кооперативная и вытесняющая многозадачность. Какой тип многозадачности использует Java? Чем обусловлен этот выбор?

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

Преимущества такого подхода - простота реализации, меньшие накладные расходы на переключение контекста.

Недостатки - если один поток завис или ведет себя некорректно, то зависает целиком вся система и другие потоки никогда не получат управление.

Java использует вытесняющую многозадачность, при которой решение о переключении между потоками процесса принимает операционная система.

В отличие от кооперативной многозадачности управление операционной системе передаётся вне зависимости от состояния работающих приложений, благодаря чему, отдельные зависшие потоки процесса, как правило, не «подвешивают» всю систему целиком. За счёт регулярного переключения между задачами также улучшается отзывчивость приложения и повышается оперативность освобождения ресурсов, которые больше не используются.

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

⌨️ Чем отличается процесс от потока?

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

Для каждого процесса ОС создает так называемое «виртуальное адресное пространство», к которому процесс имеет прямой доступ. Это пространство принадлежит процессу, содержит только его данные и находится в полном его распоряжении. Операционная система же отвечает за то, как виртуальное пространство процесса проецируется на физическую память.

Поток(thread) — определенный способ выполнения процесса, определяющий последовательность исполнения кода в процессе. Потоки всегда создаются в контексте какого-либо процесса, и вся их жизнь проходит только в его границах. Потоки могут исполнять один и тот же код и манипулировать одними и теми же данными, а также совместно использовать описатели объектов ядра, поскольку таблица описателей создается не в отдельных потоках, а в процессах. Так как потоки расходуют существенно меньше ресурсов, чем процессы, в процессе выполнения работы выгоднее создавать дополнительные потоки и избегать создания новых процессов.

#java #process #thread

⌨️ Виртуальные потоки (Virtual Threads) — это новая возможность, представленная в Java, начиная с версии 19 (в предварительном режиме), а окончательно внедрённая в версии 21. Они позволяют создавать и управлять миллионами потоков с минимальными затратами на системные ресурсы. Виртуальные потоки облегчают работу с конкурентными задачами и устраняют необходимость в сложных библиотеках и фреймворках для управления потоками.

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

Так же, виртуальные потоки совместимы с существующим экосистемой Java, включая традиционные блокирующие операции, такие как I/O.

public class VirtualThreadsExample {
    public static void main(String[] args) throws InterruptedException {
        // Создаем виртуальный поток
        Thread virtualThread = Thread.ofVirtual().start(() -> {
            try {
                // Эмуляция длительной задачи
                Thread.sleep(1000);
                System.out.println("Hello from virtual thread!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Дожидаемся завершения потока
        virtualThread.join();
    }
}

#java #VirtualThreads

⌨️ Класс Pattern

Pattern - это класс, представляющий собой компилированное представление регулярного выражения. Он позволяет создать объект-шаблон, который можно применить к строке для поиска соответствий определенному шаблону. Для создания объекта Pattern используется статический метод compile(), который принимает на вход строку с регулярным выражением.
Пример создания объекта Pattern:

Pattern pattern = Pattern.compile("\\d");

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

#java #Pattern

⌨️ Создание скриншота

Этот код позволяет сделать снимок экрана и сохранить его в формате .png.

✅Toolkit.getDefaultToolkit().getScreenSize() — для получения размеров экрана;

✅ Robot — объект, который используется для захвата экрана;

✅ BufferedImage — объект, представляющий собой изображение экрана;

✅ ImageIO.write() — метод для сохранения захваченного изображения в файл с заданным именем и форматом.

#Java #Screenshot

⌨️ Каким образом можно создать поток?

✔️ Создать потомка класса Thread и переопределить его метод run();

✔️ Создать объект класса Thread, передав ему в конструкторе экземпляр класса, реализующего интерфейс Runnable. Этот интерфейс содержит метод run(), который будет выполняться в новом потоке. Поток закончит выполнение, когда завершится его метод run().

✔️ Вызвать метод submit() у экземпляра класса реализующего интерфейс ExecutorService, передав ему в качестве параметра экземпляр класса реализующего интерфейс Runnable или Callable (содержит метод call(), в котором описывается логика выполнения).

#java #Thread #Runnable #Callable

⌨️ Инициализация это процесс задания начальных значений переменным и объектам перед их использованием. Этот процесс необходим для того, чтобы обеспечить корректное начальное состояние переменных и объектов в программе.

Порядок инициализации

1⃣ Статические переменные: если в классе есть статические переменные, то они будут инициализированы в первую очередь. Переменные будут инициализированы в том порядке в котором идут в коде.

2⃣ Статический блок инициализации: далее сработает блок инициализации статических переменных.

3⃣ Переменные экземпляра

4⃣ Блок инициализации переменных экземпляра

5⃣ Конструктор

Вывод кода:
Static Variables initialized!
Static Initialization Block initialized!
Instance Variables initialized!
Instance Initialization Block initialized!
Constructor initialized!

Инициализация в Java является важным аспектом, который гарантирует, что объекты и переменные находятся в правильном состоянии перед их использованием. Понимание порядка инициализации помогает избегать ошибок и создавать надежные программы на Java.

⌨️ В чём заключается разница между методами start() и run() класса Thread?

Несмотря на то, что start() вызывает метод run() внутри себя, это не то же самое, что просто вызов run(). Если run() вызывается как обычный метод, то он вызывается в том же потоке и никакой новый поток не запускается, как это происходит, в случае, когда вы вызываете метод start().

#java #Thread #start #run

⌨️ В каких состояниях может находиться поток?

Потоки могут находиться в одном из следующих состояний:

✔️ Новый (New). После создания экземпляра потока, он находится в состоянии Новый до тех пор, пока не вызван метод start(). В этом состоянии поток не считается живым.

✔️ Работоспособный (Runnable). Поток переходит в состояние Работоспособный, когда вызывается метод start(). Поток может перейти в это состояние также из состояния Работающий или из состояния Блокирован. Когда поток находится в этом состоянии, он считается живым.

✔️ Работающий (Running). Поток переходит из состояния Работоспособный в состояние Работающий, когда Планировщик потоков выбирает его как работающий в данный момент.

✔️ Живой, но не работоспособный (Alive, but not runnable). Поток может быть живым, но не работоспособным по нескольким причинам:

▪️Ожидание (Waiting). Поток переходит в состояние Ожидания, вызывая метод wait(). Вызов notify() или notifyAll() может перевести поток из состояния Ожидания в состояние Работоспособный.

▪️Сон (Sleeping). Метод sleep() переводит поток в состояние Сна на заданный промежуток времени в миллисекундах.

▪️Блокировка (Blocked). Поток может перейти в это состояние, в ожидании ресурса, такого как ввод/вывод или из-за блокировки другого объекта. В этом случае поток переходит в состояние Работоспособный, когда ресурс становится доступен.

▪️Мёртвый (Dead). Поток считается мёртвым, когда его метод run() полностью выполнен. Мёртвый поток не может перейти ни в какое другое состояние, даже если для него вызван метод start().

#java #Thread #state

⌨️ Срезы в стримах. Метод takeWhile

В Java 9 появилось два новых метода, полезных для выбора элементов потока с хорошей производительностью: takeWhile и dropWhile.

Допустим, у нас есть следующий список блюд:

List<Dish> specialMenu = Arrays.asList(
new Dish("seasonal fruit", 120),
new Dish("prawns", 300),
new Dish("rice", 350),
new Dish("chicken", 400),
new Dish("french fries", 530));

Для получения блюд с калорийностью меньше 320, можно воспользоваться операцией filter. Недостаток операции filter в том, что она требует прохода в цикле по всему потоку данных с применением предиката ко всем элементам.

В нашем примере список уже отсортирован по числу калорий. Вместо того, чтобы пройтись по каждому элементу, можно прекратить работу сразу же после обнаружения блюда, содержащего 320 калорий или более. В случае небольшого списка это может показаться не таким уж громадным преимуществом, но при работе с потенциально большим потоком элементов окажется весьма полезным.

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

List<Dish> sliceMenu1 
    = specialMenu.stream()
                 .takeWhile(dish -> dish.getCalories() < 320)
                 .collect(toList());

#java #stream #takeWhile

⌨️ Срезы в стримах. Метод dropWhile

Операция dropWhile служит дополнением к операции takeWhile. Она отбрасывает первые элементы, для которых предикат возвращает true. Как только результат вычисления предиката становится ложным, она прекращает работу и возвращает все оставшиеся элементы, причем работает даже в том случае, если число оставшихся элементов бесконечно!

List<Integer> ints = List.of(1,2,3,4,5,6,7,8,9);
ints.stream()
    .dropWhile(i -> i < 5)
    .forEach(System.out::println);
// 5 6 7 8 9

#java #stream #dropWhile

⌨️ Усечение потока данных. Метод limit

Потоки данных поддерживают метод limit(n). Он возвращает еще один поток, не превышающий заданную длину, переданную в limit в виде аргумента. Если поток данных упорядоченный, возвращаются первые элементы, но не более чем n.

Например, с помощью следующего кода можно создать List, выбрав первые три блюда, содержащие более 300 калорий:

List<Dish> dishes = specialMenu
    .stream()
    .filter(dish -> dish.getCalories() > 300)
    .limit(3)
    .collect(toList());

Метод limit работает и для неупорядоченных потоков данных (например, когда источник представляет собой объект типа Set). В этом случае не следует исходить из допущения о какой-либо упорядоченности результата, возвращенного методом limit.

#java #stream #limit