​​Критическая секция. Блок кода
#новичкам

Термин "критическая секция" имеет 2 значения и это несколько конфузит как новичков, так и опытных разрабов, кто просто не встречался с двумя личинами термина. Сейчас и в следующем посте разберем оба значения.

Начнем с простого.

Одна из самых больших опасностей многопоточного кода - это гонка данных. Когда 2 потока пытаются читать и записывать в одну ячейку памяти без использования синхронизации.

Проблема гонки на самом деле в том, что потоки могут увидеть промежуточное состояние комплексной операции и вклиниться посередине. Даже банальный инкремент инта это 3 операции: чтение, модификация и запись.

int counter = 0;   // unprotected variable

void increment() {
    for (int i = 0; i < 10000; ++i) {
        ++counter;   // data race
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    // expected 20000, but there is data race so counter will never be eq to the number
    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}

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

Чуть более понятный пример:

struct Balance {
    void withdraw_balance(int amount) {
        if (balance_ >= amount {
            balance_ -= amount;
        }
    }
private:
    int balance_;
};

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

То есть существуют участки кода, внутри которых происходит доступ к разделяемому ресурсу и там каждый момент времени может исполняться максимум один поток. Такие участки кода называют критическими секциями.

Критические секции должны быть защищены примитивами синхронизации, обеспечивающими взаимное исключение потоков. Например, мьютекс:

struct Balance {
    vvoid withdraw_balance(int amount) {
        std::lock_guard lg{mtx_};
        if (balance_ >= amount {
            balance_ -= amount;
        }
    }
private:
    int balance_;
    std::mutex mtx_;
};

Критической секцией также может быть только часть функции:

template<typename T>
class ThreadSafeQueue {
    std::queue<T> queue_;
    std::mutex mtx_;
public:

    std::queue<T> pop_all() {
        std::queue<T> result;
        { // critical section begin
            std::lock_guard<std::mutex> lock(mtx_);
            std::swap(result, queue_);
        } // critical section end
        return result;
    }
};

В этом случае очень удобно обозначать ее вложеным скоупом (фигурными скобками) для лучшего выделения на фоне остального кода. Также выход из блока кода триггерит разрушение его локальных объектов, поэтому вам в большинстве случаев не нужно явно вызывать mtx.unlock().

Критические секции стоит делать как можно меньшего размера, чтобы время блокировки потоков было минимально.

Спасибо @antom1n за идею для поста

Think critical. Stay cool.

#concurrency