Псевдопараллельное выполнение

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

История и предпосылки

Концепция псевдопараллельного выполнения возникла на ранних этапах развития вычислительной техники, когда компьютеры были однопроцессорными и однопоточными. Первые операционные системы (например, ранние версии OS/360 от IBM) использовали простейшие формы псевдопараллелизма для организации пакетной обработки данных. Однако систематическое применение этого подхода началось с появлением многозадачных операционных систем в 1960-х годах.

В 1960-е годы в рамках проекта Multics (MIT, Bell Labs, General Electric) были разработаны механизмы разделения времени (time-sharing), которые позволяли нескольким пользователям одновременно работать с одной ЭВМ. Каждый пользователь получал короткий квант времени процессора, после чего управление передавалось следующему пользователю. Это был классический пример псевдопараллельного выполнения на уровне пользовательских задач.

В 1970-е годы с развитием операционных систем Unix (Кен Томпсон, Деннис Ритчи) появились системные вызовы fork() и exec(), которые позволяли создавать дочерние процессы. Планировщик Unix (scheduler) реализовывал вытесняющую многозадачность, где переключение между процессами происходило по таймеру или по приоритету. В 1980-е годы появились потоки (threads) — более лёгкие единицы выполнения, которые также могли работать в режиме псевдопараллелизма.

В 1990-е годы с развитием языков программирования (Java, C#) и библиотек (POSIX threads) псевдопараллельное выполнение стало стандартным механизмом для создания многозадачных приложений. В 2000-е годы, с ростом числа ядер в процессорах, интерес к псевдопараллелизму не угас, а трансформировался: он стал использоваться в комбинации с истинным параллелизмом для оптимизации работы с асинхронными операциями (ввод-вывод, сетевые запросы).

Отличие от истинного параллелизма

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

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

На практике в современных системах (например, в операционных системах Windows, Linux, macOS) одновременно используются оба подхода: несколько ядер обеспечивают истинный параллелизм, а на каждом ядре планировщик реализует псевдопараллелизм между потоками.

Классификация

Псевдопараллельное выполнение можно классифицировать по нескольким признакам.

По способу переключения контекста

Вытесняющая многозадачность (preemptive multitasking). Планировщик операционной системы (или виртуальной машины) принудительно прерывает выполнение текущей задачи по истечении кванта времени (обычно 10–100 мс) или при наступлении события (например, прерывание от таймера). Задача не контролирует момент переключения. Используется в большинстве современных ОС (Windows, Linux, macOS, Android, iOS).

Кооперативная многозадачность (cooperative multitasking). Задача сама добровольно передаёт управление планировщику (например, через вызов yield() или return). Если задача не отдаёт управление (например, зациклилась), система может зависнуть. Исторически использовалась в ранних версиях Windows (до Windows 95), в Mac OS Classic, в некоторых встраиваемых системах. В современных языках (Python, JavaScript, Kotlin) кооперативный подход реализован через корутины (coroutines) и асинхронные функции.

По уровню реализации

На уровне процессов (process-level). Каждый процесс имеет собственное адресное пространство. Переключение между процессами требует сохранения/восстановления контекста (регистры, таблицы страниц, файловые дескрипторы). Это ресурсоёмкая операция. Используется в ОС для изоляции задач.

На уровне потоков (thread-level). Потоки одного процесса разделяют общее адресное пространство. Переключение между потоками дешевле, чем между процессами, так как не требуется менять таблицы страниц. Используется в многопоточных приложениях.

На уровне корутин (coroutine-level). Корутины (легковесные потоки, файберы, green threads) выполняются в рамках одного потока ОС. Переключение между корутинами происходит без участия ядра ОС (user-space switching). Это максимально быстрый способ псевдопараллелизма. Примеры: goroutines в Go, async/await в C# и Python, корутины в Kotlin.

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

Системная многозадачность — управление процессами и потоками в ОС.
Прикладная многозадачность — организация параллельной работы в рамках одного приложения (например, обработка нескольких сетевых соединений в веб-сервере).
Асинхронное программирование — выполнение операций ввода-вывода без блокировки основного потока.

Устройство и механизмы

Планировщик (scheduler)

Планировщик — компонент операционной системы или среды выполнения, который определяет, какая задача будет выполняться следующей. Основные алгоритмы планирования:

Round Robin (карусель): каждой задаче выделяется фиксированный квант времени; задачи циклически сменяют друг друга.
Priority-based (по приоритету): задачи с более высоким приоритетом получают больше процессорного времени.
Multilevel Feedback Queue (многоуровневая очередь с обратной связью): задачи перемещаются между очередями в зависимости от их поведения (например, интерактивные задачи получают малые кванты, а фоновые — большие).

Переключение контекста (context switch)

При переключении контекста планировщик сохраняет состояние текущей задачи (регистры, счётчик команд, стек) в памяти, загружает состояние следующей задачи и передаёт ей управление. Время переключения контекста (overhead) зависит от аппаратной платформы и уровня (процесс/поток/корутина). Для процессов на x86-64 это может составлять 1–10 микросекунд, для корутин — 10–100 наносекунд.

Синхронизация

При псевдопараллельном выполнении задачи могут обращаться к общим данным (например, глобальным переменным, файлам). Для предотвращения состояний гонки (race conditions) используются механизмы синхронизации:

Мьютексы (mutex): блокировка доступа к ресурсу.
Семафоры: счётчики, ограничивающие количество одновременных доступов.
Условные переменные: ожидание определённого состояния.
Атомарные операции: неделимые операции чтения-модификации-записи (например, compare-and-swap).

Применение

Операционные системы

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

Веб-серверы и сетевые приложения

Веб-серверы (например, Nginx, Apache) обрабатывают тысячи одновременных соединений, используя псевдопараллелизм. Вместо создания отдельного потока на каждое соединение (что дорого), применяется асинхронная модель (event-driven) или пул потоков (thread pool). В Nginx используется асинхронный ввод-вывод с мультиплексированием (epoll, kqueue), что позволяет одному потоку обрабатывать множество соединений.

Языки программирования и среды выполнения

Python: глобальная блокировка интерпретатора (GIL) не позволяет потокам Python выполняться истинно параллельно на нескольких ядрах, поэтому многопоточность в Python является псевдопараллельной (за исключением операций ввода-вывода, которые освобождают GIL). Для истинного параллелизма используются процессы (multiprocessing).
JavaScript (Node.js): однопоточная модель с циклом событий (event loop). Все операции ввода-вывода выполняются асинхронно, а пользовательский код — в одном потоке. Это классический пример кооперативного псевдопараллелизма.
Go: горутины (goroutines) — легковесные потоки, которые мультиплексируются на потоки ОС. Планировщик Go (GMP-модель) реализует вытесняющую многозадачность на уровне горутин.
C# и .NET: async/await реализует кооперативный псевдопараллелизм на основе задач (Task) и пула потоков.

Встраиваемые системы и реальное время

В системах с жёстким реальным времени (real-time) псевдопараллельное выполнение строго регламентируется. Планировщик гарантирует, что каждая задача получит процессорное время в заданные сроки (deadlines). Примеры: FreeRTOS, VxWorks, QNX.

Преимущества и недостатки

Преимущества

Эффективность использования ресурсов: одно ядро может обслуживать множество задач, что особенно важно в системах с ограниченными вычислительными мощностями (мобильные устройства, встраиваемые системы).
Простота реализации: для создания иллюзии многозадачности не требуется множества ядер или сложной аппаратной поддержки.
Удобство программирования: разработчик может писать код, как если бы задачи выполнялись параллельно, не заботясь о распределении по ядрам.
Масштабируемость: псевдопараллелизм легко комбинируется с истинным параллелизмом (например, несколько потоков на разных ядрах).

Недостатки

Накладные расходы на переключение контекста: каждое переключение требует времени и ресурсов (сохранение/восстановление состояния). При большом количестве задач (тысячи и более) накладные расходы могут стать значительными.
Сложность синхронизации: необходимость защиты общих данных от состояний гонки может привести к ошибкам (deadlock, livelock, starvation) и снижению производительности из-за блокировок.
Отсутствие истинного ускорения для вычислительных задач: если задача загружает процессор на 100% (CPU-bound), псевдопараллелизм не ускорит её выполнение, а только добавит накладные расходы. Для таких задач требуется истинный параллелизм.
Зависимость от планировщика: неправильный выбор алгоритма планирования может привести к несправедливому распределению времени или к задержкам в ответах (latency).

Интересные факты

Термин «псевдопараллельное выполнение» иногда используется как синоним «многозадачности в одном потоке», но в технической литературе чаще применяют термин «concurrency» (конкуренция, одновременность), в отличие от «parallelism» (параллелизм). Конкуренция — это свойство программы, при котором несколько задач могут находиться в процессе выполнения, но не обязательно одновременно. Параллелизм — это свойство аппаратного обеспечения.
В операционной системе Linux для управления псевдопараллельным выполнением используется планировщик CFS (Completely Fair Scheduler), который стремится предоставить каждому потоку равную долю процессорного времени (fair scheduling).
В языке Erlang (разработан в 1986 году, Ericsson) все процессы (легковесные, не связанные с процессами ОС) выполняются псевдопараллельно в рамках одной виртуальной машины. Каждый процесс имеет собственный стек и кучу, а переключение между ними происходит без участия ядра ОС.
В некоторых системах (например, в ранних версиях Windows 3.x) использовалась кооперативная многозадачность, что приводило к зависаниям всей системы при сбое одной программы. Переход на вытесняющую многозадачность в Windows 95 значительно повысил стабильность.

Источники

Таненбаум Э., Бос Х. «Современные операционные системы». 4-е издание. — СПб.: Питер, 2015.
Стивенс Р. «UNIX: взаимодействие процессов». — СПб.: Питер, 2003.
Goetz B. et al. «Java Concurrency in Practice». — Addison-Wesley, 2006.
Официальная документация Linux Kernel: «Process Scheduling» (kernel.org).
Документация языка Go: «The Go Memory Model» (golang.org).
Документация Node.js: «The Node.js Event Loop» (nodejs.org).

BFOmetr — база данных и аналитика по компаниям России.

На главную BFOmetr →