Всегда ли потоки выполняются параллельно?

Всегда ли потоки выполняются параллельно?

Нет, выполнение потоков не всегда является параллельным. Это ключевой момент в понимании многопоточности, который часто вызывает путаницу. Параллельность зависит от нескольких фундаментальных факторов: архитектуры процессора, операционной системы и конкретной реализации многопоточности в программе.

Ключевые концепции: параллельность vs. многозадачность

Сначала важно разделить два понятия:

• Параллельность (Parallelism) — это физическое одновременное выполнение нескольких потоков на разных ядрах или процессорах. Два потока выполняют свою работу в один и тот же момент времени.
• Многозадачность (Concurrency) — это логическое одновременное выполнение, когда система переключается между потоками, создавая видимость параллельной работы. Потоки выполняются на одном ядре, разделяя его время.

Когда потоки выполняются параллельно?

Параллельное выполнение возможно только при наличии нескольких физических ядер процессора (CPU cores).

// Пример: два потока могут работать параллельно на двуядерном CPU
Thread thread1 = new Thread(() -> {
    for(int i = 0; i < 1000; i++) { /* тяжелые вычисления */ }
});
Thread thread2 = new Thread(() -> {
    for(int i = 0; i < 1000; i++) { /* тяжелые вычисления */ }
});

thread1.start();
thread2.start();
// На многоядерной системе эти потоки likely будут распределены на разные ядра

Когда потоки выполняются НЕ параллельно (конкурентно)?

1. Одноядерный процессор. Все потоки выполняются на одном ядре, используя вытесняющую многозадачность (preemptive multitasking). Операционная система (например, планировщик потоков в Android) быстро переключает контекст между потоками, делая их выполнение конкурентным, но не параллельным.

2. Большее количество потоков, чем доступных ядер. Это наиболее распространенная ситуация. Если у нас, например, 4 ядра, но 10 активных потоков, система будет распределять их между ядрами, но в каждый момент времени только 4 потока могут работать параллельно. Остальные будут находиться в состоянии ожидания или конкурентно переключаться.

3. Блокировки и синхронизация. Поток, ожидающий ресурса (например, блокировки synchronized, результата от другого потока или операции I/O), фактически не выполняет полезную работу, даже если ядро свободно.

// Пример в Android/Kotlin: потоки могут блокировать друг друга
val lock = Object()

thread1 = Thread {
    synchronized(lock) {
        // Пока thread1 держит lock, thread2 НЕ может выполнять этот блок
        // параллельно, даже если ядра свободны. Это конкурентное ожидание.
        Thread.sleep(1000)
    }
}

thread2 = Thread {
    synchronized(lock) { // Будет ждать освобождения lock от thread1
        doWork()
    }
}

1. Виртуальные потоки / Coroutines (в контексте Android/Kotlin). Корутины — это легковесные механизмы конкурентности, которые не являются потоками ОС. Они выполняются на ограниченном пуле потоков (часто Dispatchers.Default использует количество ядер). Многие корутины конкурентно работают на одном потоке, переключаясь при suspension, и только если распределены на разные потоки пула — они могут работать параллельно на разных ядрах.

// Kotlin Coroutines: две корутины могут быть запущены на одном потоке
fun example() = runBlocking {
    // Обе корутины выполняются на одном потоке runBlocking (конкурентно)
    launch {
        delay(1000) // При suspension, другая корутина может выполнять работу
        println("Coroutine 1")
    }
    launch {
        println("Coroutine 2")
    }
}

Практический вывод для Android разработчика

• На современном многоядерном Android устройстве возможна реальная параллельность, но система постоянно управляет сотнями процессов и потоков, распределяя их между ядрами.
• При разработке следует думать о конкурентности как общей модели, а параллельность рассматривать как потенциальное преимущество для выполнения тяжелых задач (обработка изображений, вычисления).
• Неверная синхронизация (блокировки, synchronized) или слишком большое количество активных потоков могут привести к ситуации, когда потоки большую часть времени ожидают, и реальная параллельность не достигается, несмотря на наличие свободных ядер.
• Использование современных средств (Coroutines, WorkManager) помогает эффективно управлять конкурентностью и потенциально использовать параллельность, предоставляемую системой.

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