☕ Java

Многопоточность и асинхронность в Java: подробное руководство

Урок 34 / 37 • Полная теория для чтения

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты — шеф-повар на огромной кухне. Тебе нужно приготовить сложный обед: суп, второе блюдо и десерт. У тебя есть только одна плита и одна духовка. Если ты будешь делать всё последовательно (сначала суп, потом второе, потом десерт), обед будет готов через 3 часа. Гости проголодаются и уйдут.

Но что, если у тебя есть помощники? Один режет овощи, второй следит за духовкой, третий взбивает крем. Пока один помощник ждёт, когда закипит вода, другой уже нарезает мясо. В итоге обед готов за 1 час. Это и есть многопоточность — одновременное выполнение нескольких задач.

А теперь представь другую ситуацию. Ты один, но у тебя есть умный таймер. Ты ставишь суп на плиту, включаешь таймер на 15 минут и идёшь резать салат. Когда таймер звонит, ты возвращаешься к супу. Ты не ждёшь у плиты, а занимаешься другими делами. Это асинхронность — ты не блокируешь себя ожиданием, а переключаешься между задачами.

Главное отличие: Многопоточность — это когда несколько поваров (потоков) работают одновременно. Асинхронность — это когда один повар (поток) умно переключается между задачами, не простаивая в ожидании.

В программировании мы часто сталкиваемся с задачами, которые требуют ожидания: чтение файла, запрос к серверу, обработка большого массива данных. Если программа будет просто ждать, пользователь увидит "зависший" экран. Многопоточность и асинхронность решают эту проблему.

Теория: как это работает изнутри

Процессы и потоки

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

В Java программа запускается как один процесс. Внутри этого процесса может быть много потоков. Главный поток называется main — это как директор, который запускает все остальные задачи.

Как работает многопоточность в Java

Java использует нативные потоки операционной системы. Когда ты создаёшь поток в Java, операционная система выделяет ему отдельное время на процессоре. Если у тебя 4-ядерный процессор, то 4 потока могут работать действительно одновременно. Остальные будут ждать своей очереди, но переключение происходит так быстро (миллисекунды), что кажется, будто всё работает одновременно.

Проблема возникает, когда несколько потоков пытаются изменить одни и те же данные. Представь, что два повара одновременно пытаются добавить соль в одно и то же блюдо. Кто-то пересолит. В Java это называется race condition (состояние гонки). Для решения этой проблемы используются синхронизаторы — как замок на двери кухни: пока один повар солит, второй ждёт.

Как работает асинхронность в Java

Асинхронность в Java реализована через CompletableFuture и ExecutorService. Это не магия — это просто умное управление потоками. Ты говоришь: "Сделай это задание, когда будет время, и сообщи мне результат". Пока задание выполняется в фоне, твой основной поток может заниматься другими делами.

Представь, что ты заказал пиццу. Ты не стоишь у двери и не ждёшь курьера — ты смотришь фильм. Когда пицца приезжает, курьер звонит в дверь (это callback — обратный вызов). Ты прерываешь фильм, забираешь пиццу и продолжаешь смотреть. Это и есть асинхронность.

Синтаксис в Java: все формы и варианты

Создание потоков: 3 способа

Способ	Когда использовать	Пример
Наследование от Thread	Простая задача, не нужно наследовать другой класс	class MyThread extends Thread
Реализация Runnable	Нужно наследовать другой класс, задача без результата	class MyTask implements Runnable
Реализация Callable	Нужно получить результат или выбросить исключение	class MyTask implements Callable<Integer>

Синхронизация: ключевые инструменты

Инструмент	Что делает	Аналогия
synchronized	Блокирует доступ к методу или блоку кода для одного потока	Туалет с замком: один зашёл — другие ждут
volatile	Гарантирует, что все потоки видят актуальное значение переменной	Доска объявлений: все видят одно и то же
ReentrantLock	Более гибкая блокировка, чем synchronized	Замок с ключом: можно попробовать заблокировать и не ждать
Semaphore	Ограничивает количество потоков, которые могут работать одновременно	Парковка: только 5 машин могут заехать
CountDownLatch	Ждёт, пока несколько потоков завершат работу	Старт гонки: ждём, пока все водители сядут в машины

Асинхронность: CompletableFuture

Метод	Что делает	Пример
supplyAsync()	Запускает задачу асинхронно и возвращает результат	CompletableFuture.supplyAsync(() -> 42)
thenApply()	Преобразует результат, когда он будет готов	future.thenApply(x -> x * 2)
thenAccept()	Выполняет действие с результатом, не возвращая ничего	future.thenAccept(System.out::println)
exceptionally()	Обрабатывает ошибку, если она возникла	future.exceptionally(ex -> 0)
allOf()	Ждёт завершения всех переданных задач	CompletableFuture.allOf(f1, f2)

Примеры кода — от простого к сложному

Пример 1: Создание потока через Thread (самый простой)

// Создаём класс, который наследует Thread
class MyFirstThread extends Thread {
    @Override
    public void run() {
        // Этот код выполнится в новом потоке
        System.out.println("Привет из потока: " + Thread.currentThread().getName());
    }
}

public class Example1 {
    public static void main(String[] args) {
        // Создаём объект нашего потока
        MyFirstThread thread = new MyFirstThread();
        
        // Запускаем поток (не путать с run()!)
        thread.start();
        
        // Главный поток тоже работает
        System.out.println("Привет из главного потока: " + Thread.currentThread().getName());
        
        // Вывод может быть в любом порядке — потоки работают независимо!
    }
}

Пример 2: Создание потока через Runnable (правильный способ)

// Runnable — это интерфейс с одним методом run()
class MyTask implements Runnable {
    private String taskName;
    
    public MyTask(String taskName) {
        this.taskName = taskName;
    }
    
    @Override
    public void run() {
        // Имитируем долгую работу (например, загрузку файла)
        for (int i = 0; i < 5; i++) {
            System.out.println(taskName + " выполняет шаг " + i);
            try {
                // Заставляем поток "поспать" — имитация ожидания
                Thread.sleep(100); // 100 миллисекунд
            } catch (InterruptedException e) {
                // Если поток прервали, выходим
                System.out.println(taskName + " был прерван!");
                return;
            }
        }
        System.out.println(taskName + " завершён!");
    }
}

public class Example2 {
    public static void main(String[] args) {
        // Создаём задачи
        MyTask task1 = new MyTask("Загрузчик №1");
        MyTask task2 = new MyTask("Загрузчик №2");
        
        // Создаём потоки и передаём им задачи
        Thread thread1 = new Thread(task1);
        Thread thread2 = new Thread(task2);
        
        // Запускаем потоки
        thread1.start();
        thread2.start();
        
        // Ждём, пока оба потока завершатся
        try {
            thread1.join(); // main ждёт thread1
            thread2.join(); // main ждёт thread2
        } catch (InterruptedException e) {
            System.out.println("Главный поток прерван");
        }
        
        System.out.println("Все задачи выполнены! Программа завершена.");
    }
}

Пример 3: Проблема состояния гонки (Race Condition)

class Counter {
    private int count = 0;
    
    // Проблема: этот метод не синхронизирован!
    public void increment() {
        // Операция count++ на самом деле состоит из 3 шагов:
        // 1. Прочитать значение count
        // 2. Увеличить на 1
        // 3. Записать обратно
        // Два потока могут прочитать одно и то же значение!
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

public class Example3 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        // Создаём 1000 потоков, каждый увеличивает счётчик на 1
        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    counter.increment();
                }
            });
            threads[i].start();
        }
        
        // Ждём все потоки
        for (Thread t : threads) {
            t.join();
        }
        
        // Ожидаем 100000, но получаем меньше!
        System.out.println("Фактический результат: " + counter.getCount());
        System.out.println("Ожидаемый результат: 100000");
        // Из-за гонки потоков результат будет меньше!
    }
}

Пример 4: Решение проблемы через synchronized

class SafeCounter {
    private int count = 0;
    
    // Ключевое слово synchronized гарантирует, 
    // что только один поток может выполнять этот метод одновременно
    public synchronized void increment() {
        count++;
    }
    
    // Чтение тоже нужно синхронизировать, чтобы увидеть актуальное значение
    public synchronized int getCount() {
        return count;
    }
}

public class Example4 {
    public static void main(String[] args) throws InterruptedException {
        SafeCounter counter = new SafeCounter();
        
        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    counter.increment();
                }
            });
            threads[i].start();
        }
        
        for (Thread t : threads) {
            t.join();
        }
        
        // Теперь результат всегда правильный!
        System.out.println("Фактический результат: " + counter.getCount());
        System.out.println("Ожидаемый результат: 100000");
    }
}

Пример 5: Использование ExecutorService (пул потоков)

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

public class Example5 {
    public static void main(String[] args) {
        // Создаём пул из 4 потоков
        // Это как нанять 4 помощников, которые будут выполнять задачи
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        // Отправляем 10 задач на выполнение
        for (int i = 1; i <= 10; i++) {
            int taskId = i;
            executor.submit(() -> {
                System.out.println("Задача " + taskId + 
                                   " выполняется в потоке " + 
                                   Thread.currentThread().getName());
                try {
                    // Имитируем работу
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Задача " + taskId + " завершена");
            });
        }
        
        // Важно! Останавливаем executor, иначе программа не завершится
        executor.shutdown();
        
        try {
            // Ждём завершения всех задач, но не больше 10 секунд
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                // Если задачи не завершились за 10 секунд, принудительно останавливаем
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
        
        System.out.println("Все задачи выполнены!");
    }
}

Пример 6: CompletableFuture — асинхронность без боли

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Example6 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Запускаем асинхронную задачу, которая вернёт число
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Вычисляем в фоне...");
            try {
                Thread.sleep(2000); // Имитация долгого вычисления
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return 42;
        });
        
        // Пока вычисление идёт, мы можем делать другие дела
        System.out.println("Делаем другие дела...");
        
        // Цепочка преобразований: когда результат будет готов, 
        // он пройдёт через все этапы
        CompletableFuture resultFuture = future
            .thenApply(result -> result * 2)        // Удваиваем
            .thenApply(result -> "Ответ: " + result) // Преобразуем в строку
            .exceptionally(ex -> "Ошибка: " + ex.getMessage()); // Обрабатываем ошибки
        
        // Ждём результат (блокируем текущий поток)
        String result = resultFuture.get();
        System.out.println(result);
        
        // Более элегантный способ: callback, который выполнится, когда результат готов
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "Привет из будущего!";
        }).thenAccept(System.out::println); // Просто выводим результат
        
        // Даём время завершиться последней задаче
        Thread.sleep(2000);
    }
}

Пример 7: Комбинирование нескольких асинхронных задач

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Example7 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Представь, что мы заказываем пиццу и ждём доставку
        CompletableFuture orderPizza = CompletableFuture.supplyAsync(() -> {
            System.out.println("Готовим пиццу...");
            try {
                Thread.sleep(3000); // 3 секунды на приготовление
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "Пицца Маргарита";
        });
        
        // Параллельно заказываем напиток
        CompletableFuture orderDrink = CompletableFuture.supplyAsync(() -> {
            System.out.println("Наливаем напиток...");
            try {
                Thread.sleep(1000); // 1 секунда
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "Кола";
        });
        
        // Ждём оба заказа и объединяем результаты
        CompletableFuture combinedOrder = orderPizza
            .thenCombine(orderDrink, (pizza, drink) -> {
                return "Заказ готов: " + pizza + " и " + drink;
            });
        
        // Выводим результат
        System.out.println(combinedOrder.get());
        
        // Пример с allOf — ждём все задачи
        CompletableFuture task1 = CompletableFuture.supplyAsync(() -> "A");
        CompletableFuture task2 = CompletableFuture.supplyAsync(() -> "B");
        CompletableFuture task3 = CompletableFuture.supplyAsync(() -> "C");
        
        CompletableFuture allTasks = CompletableFuture.allOf(task1, task2, task3);
        
        // Ждём завершения всех
        allTasks.get();
        
        // Теперь можно получить результаты каждой
        System.out.println(task1.get() + task2.get() + task3.get()); // Выведет "ABC"
    }
}

Сравнение с Python: чем похоже и чем отличается

Характеристика	Java	Python
Нативные потоки	Да, использует потоки ОС	Да, но есть GIL (Global Interpreter Lock)
GIL (Global Interpreter Lock)	Нет GIL — потоки работают по-настоящему параллельно	Есть GIL — только один поток выполняется в каждый момент времени
Синтаксис создания потока	new Thread(() -> {...}).start()	threading.Thread(target=func).start()
Асинхронность	CompletableFuture, ExecutorService	asyncio, async/await
Сложность	Выше (много boilerplate кода)	Ниже (лаконичный синтаксис)
Производительность	Выше для CPU-интенсивных задач	Выше для I/O-интенсивных задач (благодаря asyncio)
Пул потоков	ExecutorService (встроенный)	ThreadPoolExecutor (из concurrent.futures)

Важное отличие: В Python из-за GIL многопоточность не даёт прироста для задач, нагружающих процессор (CPU-bound). Для таких задач в Python используют multiprocessing. В Java многопоточность эффективна и для CPU, и для I/O задач.

Типичные ошибки и подводные камни

1. Вызов run() вместо start()

Самая распространённая ошибка новичков. Если вызвать thread.run(), код выполнится в текущем потоке, а не в новом. Поток не создаётся!

2. Отсутствие синхронизации

Забываешь про synchronized — получаешь race condition. Данные портятся, программа работает непредсказуемо.

3. Deadlock (взаимная блокировка)

Два потока ждут друг друга: первый держит ресурс A и ждёт B, второй держит B и ждёт A. Оба застыли навечно.

// Пример deadlock
class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized(lock1) {
            System.out.println("Захватили lock1");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized(lock2) {
                System.out.println("Захватили lock2");
            }
        }
    }
    
    public void method2() {
        synchronized(lock2) { // Внимание! Порядок захвата другой!
            System.out.println("Захватили lock2");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized(lock1) {
                System.out.println("Захватили lock1");
            }
        }
    }
}

4. Забыл остановить ExecutorService

Если не вызвать shutdown(), программа будет висеть вечно, даже после выполнения всех задач.

5. Игнорирование InterruptedException

Многие просто "проглатывают" исключение. Это неправильно — нужно восстанавливать флаг прерывания:

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // Правильно: восстанавливаем флаг прерывания
    Thread.currentThread().interrupt();
    // И выходим из задачи
    return;
}

6. Слишком много потоков

Создание тысяч потоков "на каждый чих" — плохая идея. Каждый поток потребляет память (около 1 МБ стека). Используй пул потоков!

Лучшие практики и советы профессионалов

1. Используй пул потоков, а не создавай потоки вручную

Вместо new Thread() используй Executors.newFixedThreadPool(). Это экономит ресурсы и упрощает управление.

2. Предпочитай immutable (неизменяемые) объекты

Если объект нельзя изменить после создания, он безопасен для использования в многопоточности. Никаких блокировок не нужно!

3. Используй высокоуровневые конструкции

Вместо synchronized и wait/notify используй ReentrantLock, Semaphore, CountDownLatch. Они менее подвержены ошибкам.

4. Минимизируй критические секции

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

5. Используй CompletableFuture для асинхронных операций

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

6. Тестируй многопоточный код

Используй специальные инструменты: ThreadMXBean для мониторинга, jstack для поиска deadlock'ов, фреймворки вроде JCStress для тестирования.

7. Помни про атомарные классы

Для простых счётчиков и флагов используй AtomicInteger, AtomicBoolean и т.д. Они быстрее и безопаснее, чем synchronized.

import java.util.concurrent.atomic.AtomicInteger;

class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        // Атомарная операция — не требует synchronized!
        count.incrementAndGet();
    }
    
    public int getCount() {
        return count.get();
    }
}

Вопросы для самопроверки

В чём разница между процессом и потоком?
Ответ: Процесс — это изолированная программа со своей памятью. Поток — это лёгкая подзадача внутри процесса, которая разделяет память с другими потоками того же процесса.
Что произойдёт, если вызвать thread.run() вместо thread.start()?
Ответ: Код выполнится в текущем потоке, а не в новом. Новый поток не создаётся. Это одна из самых частых ошибок новичков.
Что такое состояние гонки (race condition)?
Ответ: Ситуация, когда два или более потока одновременно обращаются к общим данным, и результат зависит от того, какой поток выполнится первым. Это приводит к непредсказуемым результатам.
Как ключевое слово synchronized решает проблему гонки?
Ответ: synchronized гарантирует, что только один поток может выполнять помеченный метод или блок кода в каждый момент времени. Остальные потоки ждут своей очереди.
Что такое deadlock и как его избежать?
Ответ: Deadlock — это ситуация, когда два потока навсегда блокируют друг друга, ожидая ресурсы, которые удерживает другой поток. Избежать можно, всегда захватывая блокировки в одном и том же порядке.
В чём преимущество ExecutorService перед созданием потоков вручную?
Ответ: ExecutorService управляет пулом потоков, переиспользует их, ограничивает количество одновременных потоков и упрощает завершение работы. Это экономит ресурсы и уменьшает вероятность ошибок.
Что такое CompletableFuture и чем он отличается от обычного Future?
Ответ: CompletableFuture — это улучшенная версия Future, которая позволяет объединять асинхронные задачи в цепочки, обрабатывать ошибки и комбинировать результаты без блокировки потока.
Почему в Python многопоточность не даёт прироста для CPU-интенсивных задач?
Ответ: Из-за GIL (Global Interpreter Lock) — глобальной блокировки интерпретатора Python. Только один поток может выполнять Python-код в каждый момент времени. Для CPU-задач в Python используют multiprocessing.
Что такое атомарные классы и когда их использовать?
Ответ: Атомарные классы (AtomicInteger, AtomicBoolean и др.) обеспечивают потокобезопасные операции без использования synchronized. Их используют для простых счётчиков, флагов и других операций, которые можно выполнить одной инструкцией процессора.
Как правильно обработать InterruptedException?
Ответ: Нужно восстановить флаг прерывания вызовом Thread.currentThread().interrupt() и завершить выполнение задачи. Нельзя просто "проглатывать" исключение.

Итог и что изучить дальше

Мы прошли большой путь от простых аналогий до реального кода. Ты узнал:

Что такое многопоточность и асинхронность на примере кухни и пиццы
Как создавать потоки тремя способами
Как избегать состояния гонки с помощью synchronized
Как использовать пулы потоков и CompletableFuture
Какие ошибки подстерегают новичков
Чем Java отличается от Python в мире многопоточности

Это только начало. Многопоточность — одна из самых сложных тем в программировании. Вот что стоит изучить дальше:

Java Memory Model (JMM) — как Java управляет памятью в многопоточной среде
Concurrent Collections — потокобезопасные коллекции (ConcurrentHashMap, CopyOnWriteArrayList)
Fork/Join Framework — для эффективного распараллеливания рекурсивных задач
Reactive Programming — Project Reactor, RxJava (следующий уровень асинхронности)
Тестирование многопоточного кода — как писать тесты, которые ловят race condition
Паттерны многопоточности — Producer-Consumer, Thread Pool, Active Object

Золотое правило: Многопоточность — это мощный инструмент, но он требует дисциплины. Всегда думай: "Что может пойти не так, если два потока выполнят этот код одновременно?" Если не знаешь — добавь синхронизацию или используй более высокоуровневую абстракцию.

Помни: даже опытные разработчики иногда допускают ошибки в многопоточном коде. Не бойся экспериментировать, используй отладчик и профилировщик. И главное — практикуйся! Напиши свой многопоточный чат, симуляцию очереди в магазине или параллельный калькулятор. Только через практику приходит настоящее понимание.

← Предыдущая Паттерны проектирования в Java: подробное руководс Вперёд → Работа с сетью и HTTP API в Java: подробное руково