Почему обработка сложения чисел от 1 до 100 будет быстрее, если вместо Stream использовать Parallel Stream?

Обработка суммы от 1 до 100: Stream vs Parallel Stream

Это частая ошибка в собеседованиях — предположение, что ParallelStream всегда быстрее. На самом деле для сложения чисел от 1 до 100 обычный Stream будет значительно быстрее. Позвольте объяснить почему.

Почему Parallel Stream НЕ будет быстрее

1. Overhead параллелизма

Параллелизм имеет затраты на инициализацию:

// Параллельный поток
long sum = IntStream.rangeClosed(1, 100)
    .parallel()
    .sum();

Для 100 элементов параллельный поток должен:

• Создать несколько потоков (обычно по числу CPU ядер)
• Разделить работу между ними
• Синхронизировать результаты через shared-state
• Слить результаты обратно

Все эти операции имеют накладные расходы (overhead). Для 100 операций сложения эти расходы будут больше, чем сама работа.

2. Правило 10,000+ элементов

Параллельные потоки эффективны, когда:

• Элементов достаточно много (обычно 10,000+)
• Операция над каждым элементом дорогостоящая

Для 100 элементов с простой операцией сложения это не выполняется.

3. Fork/Join Pool

Параллельный поток под капотом использует ForkJoinPool:

public int sum() {
    // Неявно использует ForkJoinPool.commonPool()
    // Работает через рекурсивное разделение
    return IntStream.rangeClosed(1, 100)
        .parallel()
        .sum();
}

Even для common pool создание задачи и её добавление в очередь имеет overhead.

Сравнение производительности

public class StreamPerformanceTest {
    
    public static void main(String[] args) {
        // Warmup
        for (int i = 0; i < 1000; i++) {
            testSequential();
            testParallel();
        }
        
        // Измерение
        long start1 = System.nanoTime();
        for (int i = 0; i < 100_000; i++) {
            testSequential();
        }
        long sequential = System.nanoTime() - start1;
        
        long start2 = System.nanoTime();
        for (int i = 0; i < 100_000; i++) {
            testParallel();
        }
        long parallel = System.nanoTime() - start2;
        
        System.out.println("Sequential: " + sequential);
        System.out.println("Parallel:   " + parallel);
        System.out.println("Parallel медленнее в " + 
            (double) parallel / sequential + " раз");
    }
    
    static int testSequential() {
        return IntStream.rangeClosed(1, 100).sum();
    }
    
    static int testParallel() {
        return IntStream.rangeClosed(1, 100)
            .parallel()
            .sum();
    }
}

Результат: parallel будет медленнее примерно в 10-100 раз!

Когда Parallel Stream действительно эффективен

Параллельные потоки имеют смысл в таких случаях:

// Хороший пример: большой датасет + дорогостоящая операция
List<String> urls = loadMillionUrls();

List<Response> responses = urls.stream()
    .parallel()
    .map(url -> expensiveHttpRequest(url))  // 100ms на операцию
    .collect(Collectors.toList());

Здесь:

• Элементов миллион
• Операция дорогостоящая (HTTP запрос)
• Потенциальное ускорение в 8-10 раз на 8-ядерной машине

Оптимизация для суммирования

Для простых операций вроде суммирования лучше использовать:

// Самое быстрое решение
int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}

// Или математическая формула (самая быстрая!)
int sum = 100 * 101 / 2;  // n * (n + 1) / 2

// Stream (второе место)
int sum = IntStream.rangeClosed(1, 100).sum();

Ключевой вывод

Ответ на вопрос: Parallel Stream НЕ будет быстрее для 100 элементов.

Параллельные потоки имеют смысл только когда:

1. Много элементов (10,000+)
2. Дорогостоящие операции
3. Компенсация overhead того стоит

Для малых датасетов или простых операций sequential stream значительно быстрее благодаря отсутствию overhead параллелизма.