Что такое пул потоков (ThreadPool) и зачем он нужен?

Пул потоков (ThreadPool) и его назначение

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

Проблема без пула потоков

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

// ❌ ПЛОХОЙ ПОДХОД - создание нового потока для каждой задачи
public class BadThreadManagement {
    public void processRequests(List<Request> requests) {
        for (Request request : requests) {
            Thread thread = new Thread(() -> {
                handleRequest(request);
            });
            thread.start(); // Создание нового потока для каждого запроса
            // Это может привести к созданию тысяч потоков!
        }
    }
    
    private void handleRequest(Request request) {
        // Обработка запроса
    }
}

Проблемы:

• Создание потока — дорогая операция (требует памяти и CPU)
• Переключение контекста между тысячами потоков замедляет систему
• Может привести к OutOfMemoryError
• Непредсказуемая производительность

Преимущества пула потоков

1. Переиспользование потоков Потоки из пула переиспользуются для разных задач, что экономит ресурсы.

2. Контроль количества потоков Максимальное количество потоков можно ограничить, предотвращая перегрузку системы.

3. Управление очередью задач Задачи ставятся в очередь и выполняются по мере доступности потоков.

4. Улучшенная производительность Избегаем затрат на создание/удаление потоков.

Основные компоненты ThreadPool

public interface ExecutorService extends Executor {
    // Очередь задач (Queue)
    // Рабочие потоки (Worker Threads)
    // Контроллер пула (Pool Manager)
}

Реализация простого пула потоков

import java.util.concurrent.*;

public class SimpleThreadPoolExample {
    public static void main(String[] args) {
        // Создание пула с 5 потоками
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        // Подача 10 задач в пул
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Задача " + taskId + " выполняется в потоке " + 
                    Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // Имитация работы
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Задача " + taskId + " завершена");
            });
        }
        
        // Завершение работы пула
        executor.shutdown();
        
        try {
            // Ожидание завершения всех задач
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow(); // Принудительное завершение
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
}

Типы пулов потоков (Executors)

1. FixedThreadPool — фиксированное количество потоков

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // Пул с 10 потоками
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // Задачи будут выполняться максимум 10 одновременно
        for (int i = 0; i < 100; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Выполнение задачи: " + taskId);
            });
        }
        
        executor.shutdown();
    }
}

2. CachedThreadPool — динамический пул потоков

public class CachedThreadPoolExample {
    public static void main(String[] args) throws InterruptedException {
        // Пул динамически создаёт потоки, переиспользует свободные
        ExecutorService executor = Executors.newCachedThreadPool();
        
        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            executor.execute(() -> {
                try {
                    System.out.println("Задача " + taskId + " начата");
                    Thread.sleep(1000);
                    System.out.println("Задача " + taskId + " завершена");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(5, TimeUnit.MINUTES);
    }
}

3. SingleThreadExecutor — один поток

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        // Задачи выполняются последовательно одним потоком
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Задача " + taskId + " начата");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Задача " + taskId + " завершена");
            });
        }
        
        executor.shutdown();
    }
}

4. ScheduledThreadPool — планирование задач

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

public class ScheduledThreadPoolExample {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
        
        // Выполнить один раз через 2 секунды
        scheduler.schedule(() -> {
            System.out.println("Выполняется один раз через 2 сек");
        }, 2, TimeUnit.SECONDS);
        
        // Выполнять периодически каждые 3 секунды с задержкой 1 сек
        scheduler.scheduleAtFixedRate(() -> {
            System.out.println("Периодическое выполнение");
        }, 1, 3, TimeUnit.SECONDS);
        
        // Дождёмся завершения
        Thread.sleep(10000);
        scheduler.shutdown();
    }
}

Использование Future для получения результатов

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        // Отправка задачи, которая возвращает результат
        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(2000);
            return 42; // Результат
        });
        
        System.out.println("Задача отправлена");
        
        // Ожидание результата (блокирующий вызов)
        Integer result = future.get(); // Это блокирует текущий поток
        System.out.println("Результат: " + result);
        
        // Или с timeout
        try {
            Integer resultWithTimeout = future.get(3, TimeUnit.SECONDS);
            System.out.println("Получен результат: " + resultWithTimeout);
        } catch (TimeoutException e) {
            System.out.println("Timeout при ожидании результата");
            future.cancel(true); // Отмена задачи
        }
        
        executor.shutdown();
    }
}

ThreadPoolExecutor для продвинутого управления

import java.util.concurrent.*;

public class CustomThreadPoolExample {
    public static void main(String[] args) throws InterruptedException {
        // Создание пула с полным контролем параметров
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5,           // corePoolSize - минимальное количество потоков
            10,          // maxPoolSize - максимальное количество потоков
            60,          // keepAliveTime
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(20), // Очередь задач
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy() // Политика при переполнении очереди
        );
        
        // Подача задач
        for (int i = 0; i < 30; i++) {
            final int taskId = i;
            try {
                executor.execute(() -> {
                    System.out.println("Выполнение задачи: " + taskId);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            } catch (RejectedExecutionException e) {
                System.out.println("Задача " + taskId + " отклонена - очередь переполнена");
            }
        }
        
        // Статистика пула
        System.out.println("Активные потоки: " + executor.getActiveCount());
        System.out.println("Выполнено задач: " + executor.getCompletedTaskCount());
        
        executor.shutdown();
        executor.awaitTermination(5, TimeUnit.MINUTES);
    }
}

Политики обработки переполнения очереди

public class RejectionPoliciesExample {
    public static void main(String[] args) {
        // AbortPolicy - выбрасывает исключение (по умолчанию)
        ThreadPoolExecutor executor1 = new ThreadPoolExecutor(
            2, 2, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1),
            new ThreadPoolExecutor.AbortPolicy()
        );
        
        // CallerRunsPolicy - выполняет задачу в потоке вызывающей стороны
        ThreadPoolExecutor executor2 = new ThreadPoolExecutor(
            2, 2, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
        
        // DiscardPolicy - игнорирует задачу
        ThreadPoolExecutor executor3 = new ThreadPoolExecutor(
            2, 2, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1),
            new ThreadPoolExecutor.DiscardPolicy()
        );
        
        // DiscardOldestPolicy - отбрасывает самую старую задачу
        ThreadPoolExecutor executor4 = new ThreadPoolExecutor(
            2, 2, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1),
            new ThreadPoolExecutor.DiscardOldestPolicy()
        );
    }
}

Рекомендации по использованию

1. Для I/O-bound задач (сеть, диск): используй большой пул потоков
2. Для CPU-bound задач (вычисления): пул размером = количество CPU ядер
3. Всегда правильно завершай пул: используй shutdown() и awaitTermination()
4. Обрабатывай исключения в задачах пула
5. Избегай deadlock: не ждите результаты других задач из пула
6. Мониторь пул: отслеживай активные потоки и выполненные задачи