Зачем нужны примитивы синхронизации в одноядерной архитектуре при многопоточности?

Зачем нужны примитивы синхронизации на одноядерном процессоре

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

Ключевые аспекты проблемы

1. Вытеснение и переключение контекста

Одноядерный процессор выполняет только один поток в конкретный момент времени, но планировщик ОС может принудительно вытеснить (preempt) текущий поток в любой точке его выполнения (обычно по истечению кванта времени или при системном вызове). Это приводит к race condition, даже без истинного параллелизма.

Пример опасного сценария (инкремент разделяемой переменной):

// Разделяемый ресурс
int counter = 0;

// Операция инкремента НЕ является атомарной на уровне процессора:
// 1. Прочитать значение counter в регистр
// 2. Увеличить регистр на 1
// 3. Записать значение обратно в память

Если поток A выполняет шаг 1 (читает counter=0), затем его вытесняет планировщик, и поток B полностью выполняет все три шага (записывает counter=1), после возобновления поток A продолжит с шага 2, используя устаревшее значение (0), и в итоге запишет 1 вместо корректного 2.

2. Атомарность операций

Большинство операций, даже простые i++ в Java/C++, не являются атомарными на аппаратном уровне (за исключением операций с гарантированной атомарностью для определённых типов данных и выравнивания). Без синхронизации возможно частичное выполнение операции, её прерывание и последующее некорректное завершение.

3. Видимость изменений (Memory Visibility)

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

Пример проблемы видимости в Java (даже с volatile решается только часть проблем):

class Shared {
    private int value;
    private boolean ready;
    
    void writer() {
        value = 42;          // (1)
        ready = true;        // (2) Может быть переупорядочено с (1) компилятором/процессором!
    }
    
    void reader() {
        if (ready) {         // Может увидеть true, но value ещё 0
            System.out.println(value);
        }
    }
}

4. Координация и упорядочение доступа

Потоки часто должны взаимодействовать по определённым правилам: producer-consumer, ожидание условий, последовательное выполнение задач. Синхронизация обеспечивает управление очередностью и условиями продолжения работы.

Основные примитивы и их роль

• Мьютекс (Mutex) — гарантирует взаимное исключение (mutual exclusion) для критических секций. Только один поток может владеть мьютексом и выполнять защищённый код.
• Семафор (Semaphore) — ограничивает количество одновременных потоков в определённой секции (например, для пула ресурсов).
• Условные переменные (Condition Variables) — позволяют потокам ждать определённого условия, освобождая мьютекс на время ожидания, и эффективно уведомлять о его изменении.
• Атомарные операции (атомики) — предоставляют аппаратно-поддерживаемые атомарные чтение-модификация-запись для простых типов (например, AtomicInteger в Java).

Пример на Java (актуально для одноядерной среды)

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int value = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();          // Без этой блокировки возможна потеря обновлений
        try {
            value++;          // Критическая секция
        } finally {
            lock.unlock();
        }
    }
    
    public int getValue() {
        lock.lock();
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }
}

Даже на одноядерном процессоре без lock возможны race condition из-за вытеснения потока между чтением и записью value.

Вывод

Таким образом, примитивы синхронизации на одноядерной архитектуре необходимы для:

• Предотвращения race condition из-за вытесняющего многозадачного планирования.
• Гарантии атомарности составных операций.
• Обеспечения видимости изменений между потоками (через барьеры памяти).
• Организации корректного взаимодействия и координации потоков.

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