Многопоточность в Java: эффективное параллельное программирование

Введение в многопоточность

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

Многозадачность на уровне ОС распределяет процессорное время между процессами. Многопоточность переносит эту идею внутрь одного приложения: потоки внутри процесса делят ресурсы (память, файловые дескрипторы), но выполняются независимо.

Жизненный цикл потока

Поток проходит через несколько состояний:

• NEW (Новый) — поток создан, но не запущен (new Thread()).
• RUNNABLE (Выполняемый) — после вызова start() поток готов к выполнению или уже выполняется.
• BLOCKED (Заблокирован) — ожидает монитор для входа в синхронизированный блок/метод.
• WAITING (Ожидание) — бесконечно ждет уведомления от другого потока (Object.wait(), Thread.join()).
• TIMED_WAITING (Ожидание с таймаутом) — ждет в течение заданного времени (Thread.sleep(), wait(timeout)).
• TERMINATED (Завершен) — выполнение метода run() завершилось нормально или с исключением.

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

У каждого потока есть приоритет от MIN_PRIORITY (1) до MAX_PRIORITY (10). По умолчанию — NORM_PRIORITY (5). Планировщик ОС предпочитает потоки с более высоким приоритетом, но гарантий порядка выполнения нет — это зависит от платформы.

thread.setPriority(Thread.MAX_PRIORITY);

Создание потоков: два подхода

1. Реализация интерфейса Runnable (рекомендуется)

Разделяет задачу (логику) и механизм выполнения (поток). Позволяет наследоваться от другого класса.

class Task implements Runnable {
    private String name;
    
    Task(String name) { this.name = name; }
    
    @Override
    public void run() {
        System.out.println("Запуск " + name);
        try {
            for (int i = 3; i > 0; i--) {
                System.out.println(name + ": " + i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // восстанавливаем флаг прерывания
            System.out.println(name + " прерван");
        }
        System.out.println(name + " завершен");
    }
}

public class Demo {
    public static void main(String[] args) {
        new Thread(new Task("Поток-1")).start();
        new Thread(new Task("Поток-2")).start();
    }
}

2. Наследование от класса Thread

Проще для простых случаев, но ограничивает наследование (Java не поддерживает множественное наследование классов).

class MyThread extends Thread {
    @Override
    public void run() {
        // логика потока
    }
}

// Использование:
new MyThread().start();

Основные методы класса Thread

Продвинутые темы многопоточности

Для профессиональной разработки необходимо освоить:

• Синхронизацию — synchronized, Lock, ReentrantLock, ReadWriteLock.
• Взаимодействие потоков — wait(), notify(), notifyAll(), Condition.
• Проблемы параллелизма — дедлоки (взаимные блокировки), лайвлоки, состояние гонки (race conditions).
• Потокобезопасные коллекции — ConcurrentHashMap, CopyOnWriteArrayList, блокирующие очереди (BlockingQueue).
• Executor Framework — пулы потоков (ExecutorService), Future, CompletableFuture.
• Fork/Join Framework — для рекурсивных задач (разделяй и властвуй).
• ThreadLocal — переменные, локальные для каждого потока.
• volatile и atomic переменные — для безопасной публикации изменений.

ExecutorService executor = Executors.newFixedThreadPool(3);

for (int i = 1; i <= 5; i++) {
    final int taskId = i;
    executor.submit(() -> {
        System.out.println("Задача " + taskId + " выполняется в " + Thread.currentThread().getName());
        try { Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        return "Результат " + taskId;
    });
}

executor.shutdown();
try { executor.awaitTermination(1, TimeUnit.MINUTES); } 
catch (InterruptedException e) { e.printStackTrace(); }