Можно ли запустить миллион Thread?

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

Короткий ответ: технически можно, но на практике это непрактично и опасно. Нужно понимать, почему это плохая идея.

Ограничения ОС

Системные ограничения на количество потоков:

# Linux
ulimit -u              # максимум процессов на пользователя
grep threads /proc/sys/kernel/pid_max  # макс PID

# Windows
# Теоретически: миллионы, но на практике: 10-50k

Каждый поток требует:

• Stack память: 1-2 MB по умолчанию
• Kernel structures: ~1-2 KB на контекст переключения
• Для миллиона: ~1-2 TB памяти! 😱

Проблемы

1. Потребление памяти

// Опасный код
public class BadThreadSpawning {
    public static void main(String[] args) {
        for (int i = 0; i < 1_000_000; i++) {
            new Thread(() -> {
                try { Thread.sleep(Long.MAX_VALUE); }
                catch (InterruptedException e) {}
            }).start();
        }
    }
}
// Результат: OutOfMemoryError очень быстро

2. Context switching overhead

ОС должна переключаться между миллионом потоков:

• CPU time потрачено впустую на переключение (не на работу)
• Cache misses из-за постоянной смены контекста
• Degrade performance в 100+ раз

3. Scheduler bottleneck

Линаксовый scheduler не оптимизирован для миллионов потоков. На практике после 5-10k потоков система деградирует.

Решение: Virtual Threads (Java 21+)

Virtual Threads (проект Loom) решают эту проблему:

// Java 21+
public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        // Теперь можно создать 100k+ «потоков» без проблем
        for (int i = 0; i < 1_000_000; i++) {
            executor.submit(() -> {
                System.out.println("Virtual thread: " + Thread.currentThread());
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(10, TimeUnit.SECONDS);
    }
}

Преимущества Virtual Threads:

• Объем памяти: килобайты вместо мегабайтов
• Millions потоков с нормальной производительностью
• Просто и понятно: Thread.sleep() работает без блокировки ядра

До Java 21: правильные подходы

1. Thread Pool (ExecutorService)

ExecutorService executor = Executors.newFixedThreadPool(100);
for (int i = 0; i < 1_000_000; i++) {
    executor.submit(() -> {
        // работа
    });
}
executor.shutdown();

Преимущества: ограниченное количество потоков, переиспользование.

2. Асинхронный код с CompletableFuture

List<CompletableFuture<Void>> futures = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    futures.add(CompletableFuture.runAsync(() -> {
        // асинхронная работа
    }));
}
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
    .join();

3. Reactive streams (Project Reactor, RxJava)

Flux.range(0, 1_000_000)
    .parallel(100)  // обработка 100 элементов одновременно
    .runOn(Schedulers.parallel())
    .subscribe(item -> System.out.println(item));

Практические рекомендации

• Java 21+: используй Virtual Threads для масштабируемости
• Java 8-20: Thread Pools + Reactive для миллионов задач
• Никогда не создавай потоки в цикле без ограничений
• Профилируй память и CPU перед запуском

Вот так отвечают эксперты: не запускать миллион потоков, а использовать правильный инструмент для работы.