Java - Планировщик потоков

Привет, будущие маги Java! Сегодня мы отправляемся в захватывающее путешествие в мир планировки потоков Java. Не волнуйтесь, если вы новичок в программировании – я стану вашим дружественным гидом, и мы разберем эту тему шаг за шагом. Так что взяйте свои виртуальные палочки (клавиатуры), и погружайтесь вместе с нами!

Что такое планировщик потоков?

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

Почему нам нужен планировщик потоков?

Вы можете подумать: "Почему нельзя просто позволить всем потокам выполняться, когда они захотят?" Представьте себе, если бы все артисты цирка попытались выступить одновременно – это был бы хаос! Планировщик потоков помогает поддерживать порядок, обеспечивает справедливое распределение ресурсов и улучшает общую производительность системы.

Планировщик потоков Java

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

Состояния потоков

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

1. Новый
2. Выполняемый
3. Выполняется
4. Заблокирован/Ожидает
5. Завершен

Планировщик отвечает за перемещение потоков между этими состояниями.

Создание и планировка базовых потоков

Начнем с простого примера, чтобы увидеть, как Java создает и планирует потоки:

public class SimpleThreadExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Поток 1: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Поток 2: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

thread1.start();
thread2.start();
}
}

В этом примере мы создаем два потока, которые выводят числа от 0 до 4. Вызов Thread.sleep(1000) заставляет каждый поток暂停 на 1 секунду между выводами.

Когда вы выполните эту программу, заметите, что вывод может не быть в идеальном чередующемся порядке. Это происходит потому, что планировщик Java решает, когда переключаться между потоками!

Приоритеты потоков

Java позволяет нам давать подсказки планировщику о том, какие потоки более важны. Мы можем установить приоритеты потоков с помощью метода setPriority(). Давайте изменим наш предыдущий пример:

public class ThreadPriorityExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Поток с низким приоритетом: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Поток с высоким приоритетом: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);

thread1.start();
thread2.start();
}
}

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

ScheduledExecutorService

Теперь рассмотрим более продвинутый способ планирования потоков с использованием ScheduledExecutorService. Это мощное инструмент позволяет нам планировать задачи для выполнения после задержки или с фиксированными интервалами.

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorExample {
public static void main(String[] args) {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);

Runnable task1 = () -> System.out.println("Задача 1 выполнена в: " + System.currentTimeMillis());
Runnable task2 = () -> System.out.println("Задача 2 выполнена в: " + System.currentTimeMillis());

executor.schedule(task1, 5, TimeUnit.SECONDS);
executor.scheduleAtFixedRate(task2, 0, 2, TimeUnit.SECONDS);

try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}

executor.shutdown();
}
}

В этом примере:

• Мы создаем ScheduledExecutorService с 2 потоками.
• task1 запланирована для однократного выполнения после 5-секундной задержки.
• task2 запланирована для выполнения каждые 2 секунды, начиная сразу.
• Мы позволяем программе работать в течение 10 секунд, прежде чем остановить исполнителя.

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

Методы ScheduledExecutorService

Вот таблица основных методов, предоставляемых ScheduledExecutorService:

Метод	Описание
schedule(Runnable, long, TimeUnit)	Планирует одноразовую задачу для выполнения после указанной задержки
scheduleAtFixedRate(Runnable, long, long, TimeUnit)	Планирует задачу для выполнения с периодическим интервалом, с фиксированной задержкой между началом каждого выполнения
scheduleWithFixedDelay(Runnable, long, long, TimeUnit)	Планирует задачу для выполнения с периодическим интервалом, с фиксированной задержкой между окончанием одного выполнения и началом следующего

Заключение

Итак, это было! Мы прошли через основы планировки потоков Java, от создания простых потоков до продвинутой планировки с ScheduledExecutorService. Помните, планировка потоков – это как руководство оркестром – все дело в гармонии и времени.

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

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

Credits: Image by storyset