Перейти на PRO

Что такое состояние гонки (race condition) в многопоточном программировании

Тип вопроса: Асинхронность Вероятность: 22% Категория: Python Разработчик

Ответ

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

Ключевая проблема: неатомарность операций

Даже простая операция, как counter += 1, на самом деле состоит из нескольких шагов:

  1. Чтение текущего значения counter из памяти.
  2. Увеличение этого значения в регистре процессора.
  3. Запись нового значения обратно в память.

Если два потока выполняют эти шаги вперемешку, одно из обновлений может быть потеряно.

Пример на Python

Этот код должен в итоге вывести 1_000_000, но из-за состояния гонки результат будет непредсказуемо меньше.

import threading

counter = 0

def increment():
    global counter
    for _ in range(100000):
        # Эта операция неатомарна и вызывает race condition
        counter += 1

threads = [threading.Thread(target=increment) for _ in range(10)]

for t in threads:
    t.start()

for t in threads:
    t.join()

print(f"Финальное значение счетчика: {counter}")
# Пример вывода: Финальное значение счетчика: 345123

Решение: использование блокировок (Locks)

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

import threading

counter = 0
lock = threading.Lock()

def safe_increment():
    global counter
    for _ in range(100000):
        with lock: # Блокировка приобретается при входе в блок
            # Этот код выполняет только один поток одновременно
            counter += 1
        # Блокировка автоматически освобождается при выходе

threads = [threading.Thread(target=safe_increment) for _ in range(10)]

for t in threads:
    t.start()

for t in threads:
    t.join()

print(f"Финальное значение счетчика: {counter}")
# Вывод всегда будет: Финальное значение счетчика: 1000000

Ответ 18+ 🔞

Давай разберёмся, что за пиздец творится в твоих потоках, а то у тебя там, сука, бардак полный.

Состояние гонки — это когда твои потоки, как охуевшие мартышки, одновременно лезут в одну и ту же переменную и начинают её пинать. Результат получается такой же предсказуемый, как поведение кота, на которого наступили: хрен знает, что выйдет. Всё зависит от того, в каком порядке эти долбоёбы-потоки добегут до общей памяти.

В чём, блядь, корень зла? Операции — не атомарные!

Ты думаешь, counter += 1 — это одна операция? А вот хуй там! Это целый трёхактный спектакль, ёпта:

  1. Прочитать текущее значение counter из памяти.
  2. Прибавить к нему единичку у себя в регистре.
  3. Записать результат обратно.

И если два потока начинают этот танец одновременно, они могут наступить друг другу на мозги. Один прочитал, второй прочитал, оба прибавили, оба записали — и одно обновление нахуй потерялось. Классика!

Смотри, как это выглядит в коде

Вот этот код должен выдать ровно миллион, но получится какая-то рандомная хуйня, потому что потоки друг другу мешают.

import threading

counter = 0

def increment():
    global counter
    for _ in range(100000):
        # Вот эта строчка — рассадник ебли и хаоса
        counter += 1

threads = [threading.Thread(target=increment) for _ in range(10)]

for t in threads:
    t.start()

for t in threads:
    t.join()

print(f"Финальное значение счетчика: {counter}")
# Может вывести что угодно, например: Финальное значение счетчика: 345123

Видишь? Вместо красоты — пиздец и разруха. Потоки переписывают результаты друг друга, как последние распиздяи.

Лекарство: посади их на блокировку!

Чтобы эти обезьяньи игры прекратить, нужно ввести жёсткие правила. Используй блокировку (Lock). Это как дать одному потоку ключ от сортира: зашёл, закрылся, сделал свои дела, вышел — передал ключ следующему. Порядок!

import threading

counter = 0
lock = threading.Lock() # Вот этот самый ключ

def safe_increment():
    global counter
    for _ in range(100000):
        with lock: # Поток берёт ключ и заходит
            # Теперь здесь хозяйничает только он один. Тишина и благодать.
            counter += 1
        # Выходит и автоматически отпускает блокировку

threads = [threading.Thread(target=safe_increment) for _ in range(10)]

for t in threads:
    t.start()

for t in threads:
    t.join()

print(f"Финальное значение счетчика: {counter}")
# Теперь всегда будет чётко: Финальное значение счетчика: 1000000

Вот так, блядь. Синхронизация — наше всё. Без неё твоя многопоточность превращается в цирк с конями, где все друг другу ебальники набивают. А с блокировкой — уже похоже на работу, а не на пьяную драку в общаге.

© ХакСобесов, 2026
support@hacksobesov.com