Что значит максимальное количество потоков?

Максимальное количество потоков

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

Что это означает в контексте Java

В Java есть несколько уровней, где применяется концепция максимального количества потоков:

1. Максимальное количество потоков в ОС — сколько потоков может создать вся система
2. Максимальное количество потоков в JVM — сколько потоков может создать одно приложение
3. Максимальное количество потоков в потокопуле — сколько worker-потоков используются для обработки задач

Максимум потоков в ОС

Определяется на уровне операционной системы:

Linux:

cat /proc/sys/kernel/threads-max
ulimit -u  # Максимум процессов для одного пользователя

Обычно это 127000 потоков на систему или ~1000 потоков на пользователя. Это можно изменить в /etc/security/limits.conf

Windows: Практически не имеет ограничений, но память быстро кончается.

Максимум потоков в JVM

В Java нет явного лимита в коде, но есть практические ограничения:

public class ThreadLimitExample {
    public static void main(String[] args) {
        int count = 0;
        try {
            while (true) {
                new Thread(() -> {
                    try {
                        Thread.sleep(Long.MAX_VALUE);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }).start();
                count++;
                if (count % 1000 == 0) {
                    System.out.println("Created " + count + " threads");
                }
            }
        } catch (OutOfMemoryError e) {
            System.out.println("Could not create thread " + count);
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Обычно JVM может создать от 1000 до 10000 потоков перед OutOfMemoryError, в зависимости от:

• Размера heap (-Xmx)
• Размера thread stack (-Xss)
• Количества памяти в ОС

Максимум потоков в ThreadPool (Thread Executor)

Это САМОЕ ВАЖНОЕ для production систем. ExecutorService позволяет конфигурировать максимальное количество потоков:

// FixedThreadPool с максимум 10 потоками
ExecutorService executor = Executors.newFixedThreadPool(10);

for (int i = 0; i < 100; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
    });
}

// Очередь будет хранить оставшиеся 90 задач
executor.shutdown();

ThreadPoolExecutor — полный контроль

Для максимального контроля используй ThreadPoolExecutor с явными параметрами:

public class CustomThreadPoolExample {
    public static void main(String[] args) {
        // corePoolSize = 5 постоянных потоков
        // maximumPoolSize = 20 максимум потоков
        // Если приходит больше 20 задач, остальные идут в очередь
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5,                          // corePoolSize
            20,                         // maximumPoolSize
            60,                         // keepAliveTime
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100),  // очередь на 100 задач
            new ThreadFactory() {
                private int threadNumber = 0;
                @Override
                public Thread newThread(Runnable r) {
                    Thread t = new Thread(r);
                    t.setName("PoolThread-" + (++threadNumber));
                    return t;
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy()  // что делать при переполнении
        );
        
        // Запуск задач
        for (int i = 0; i < 150; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " by " + Thread.currentThread().getName());
            });
        }
        
        executor.shutdown();
    }
}

Параметры ThreadPoolExecutor

corePoolSize — количество постоянно работающих потоков. Даже если нет работы, они остаются.

maximumPoolSize — максимум потоков, которые будут созданы. Если приходит больше задач — идут в очередь.

keepAliveTime — время, после которого лишние потоки (сверх core) удаляются при отсутствии работы.

Queue — очередь для задач, которые ожидают выполнения.

RejectedExecutionHandler — что делать, если очередь переполнена и нельзя создать новый поток:

// Разные стратегии:

// 1. CallerRunsPolicy — выполнить в потоке, который отправил задачу
new ThreadPoolExecutor.CallerRunsPolicy()

// 2. AbortPolicy — выбросить исключение RejectedExecutionException
new ThreadPoolExecutor.AbortPolicy()

// 3. DiscardPolicy — просто выбросить задачу
new ThreadPoolExecutor.DiscardPolicy()

// 4. DiscardOldestPolicy — выбросить самую старую задачу в очереди
new ThreadPoolExecutor.DiscardOldestPolicy()

// 5. Custom
Executor.setRejectedExecutionHandler((r, executor) -> {
    logger.error("Task rejected");
});

Как выбрать максимальное количество потоков

Для CPU-bound задач:

• Максимум = количество процессорных ядер + 1
• Пример: сервер с 16 ядрами -> 17 потоков

int coreCount = Runtime.getRuntime().availableProcessors();
int poolSize = coreCount + 1;

Для I/O-bound задач:

• Максимум может быть намного больше
• Правило: M = (T * L) / C, где:
  • T = target latency (100 ms)
  • L = average latency одной операции (10 ms для DB запроса)
  • C = количество ядер (16)

int cores = Runtime.getRuntime().availableProcessors();
int targetLatency = 100;  // ms
int avgLatency = 10;      // ms
int poolSize = cores * (targetLatency / avgLatency);
// = 16 * (100 / 10) = 160 потоков

Spring Boot Configuration

@Configuration
public class ExecutorConfig {
    
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-task-");
        executor.initialize();
        return executor;
    }
}

@Service
public class AsyncService {
    
    @Async("taskExecutor")
    public void longRunningTask() {
        // Выполнится в отдельном потоке из пула
    }
}

Мониторинг текущего количества потоков

public class ThreadMonitoring {
    public static void main(String[] args) {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        
        while (true) {
            System.out.println("Active threads: " + threadBean.getThreadCount());
            System.out.println("Peak threads: " + threadBean.getPeakThreadCount());
            System.out.println("Total started: " + threadBean.getTotalStartedThreadCount());
            
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

Проблемы при неправильном конфигурировании

Слишком мало потоков:

• Низкий throughput
• Высокая latency
• Недоиспользование процессора

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

• Context switching overhead
• Потребление памяти (каждый поток требует stack space)
• OutOfMemoryError
• Медленнее работает из-за контенции

Вывод

Максимальное количество потоков — это количество одновременно работающих потоков в системе. В Java это контролируется через ThreadPoolExecutor с параметром maximumPoolSize. Выбор оптимального значения зависит от типа нагрузки: для CPU-bound = количество ядер, для I/O-bound = можно увеличить в зависимости от latency. Неправильная конфигурация приводит к performance issues или OutOfMemoryError. Это требует тестирования и мониторинга в production.