⚙️ C++

Многопоточность и асинхронность в C++: подробное руководство

Урок 36 / 39 • Полная теория для чтения

Что это такое и зачем? (аналогия из реальной жизни)

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

Последовательная работа (без многопоточности): Вы говорите помощнику: «Сначала нарежь овощи для супа. Закончил? Теперь нарежь салат. Готово? Теперь взбивай крем для десерта». Всё делается строго по очереди. Если помощник режет овощи, вы стоите и ждете — вы не можете одновременно мыть посуду или проверять заказы. Это медленно и неэффективно.

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

Асинхронность: Вы даете задание помощнику: «Поставь суп вариться на 20 минут. Пока он варится, не стой — иди нарезай салат». Помощник запускает долгую задачу (варка) и, не дожидаясь её завершения, переключается на другую работу. Когда суп сварится, помощник (или таймер) вам сообщит: «Суп готов!». Вы не тратите время на ожидание.

Главная идея: Многопоточность — это про одновременное выполнение (параллелизм). Асинхронность — это про ожидание без блокировки (когда одна задача ждет, другая работает).

Зачем это нужно в программировании?

Скорость: Разделить сложную задачу на части и решать их одновременно (например, обработка изображений, рендеринг видео).
Отзывчивость интерфейса: Пока программа скачивает файл из интернета (долгая операция), интерфейс не должен «зависать». Поток скачивания работает в фоне, а главный поток рисует кнопки и реагирует на клики.
Эффективность: Использовать все ядра процессора на 100%, а не держать 7 из 8 ядер в простое.

Теория: как это работает изнутри

Процессы и потоки

Процесс — это запущенная программа со своей собственной памятью. Два процесса (например, браузер и игра) изолированы друг от друга: если один упадет, второй продолжит работу.

Поток (thread) — это «легковесный» процесс внутри процесса. У всех потоков одного процесса общая память. Они могут читать и менять одни и те же переменные. Это удобно для обмена данными, но опасно: если два потока одновременно изменят одну переменную, возникнет гонка данных (data race).

Как процессор выполняет потоки

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

Проблема синхронизации

Представьте: два потока хотят записать деньги на банковский счет. Оба читают баланс (1000 рублей), оба прибавляют 500, оба записывают 1500. Но должно быть 2000! Это гонка данных. Для защиты используются мьютексы (mutex) — «замки». Поток захватывает мьютекс, работает с данными, отпускает. Другой поток ждет, пока замок освободится.

Асинхронность на уровне ОС

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

Синтаксис в C++: все формы и варианты

В C++ многопоточность появилась в стандарте C++11. До этого использовались библиотеки ОС (pthreads в Linux, WinAPI в Windows). Современный C++ предоставляет кроссплатформенные средства.

Основные компоненты (заголовочный файл `<thread>`)

Класс/Функция	Описание
`std::thread`	Создает новый поток. Принимает функцию (или лямбду) для выполнения.
`std::mutex`	Мьютекс (взаимное исключение). Защищает общие данные.
`std::lock_guard`	Умная обертка для мьютекса. Автоматически захватывает при создании и отпускает при разрушении.
`std::unique_lock`	Более гибкая версия lock_guard. Можно вручную захватывать и отпускать.
`std::atomic`	Атомарные переменные. Операции с ними (чтение, запись) неделимы — не нужен мьютекс.
`std::async`	Запускает асинхронную задачу. Возвращает `std::future`.
`std::future`	Хранит результат асинхронной операции, который будет получен в будущем.
`std::promise`	Позволяет вручную установить значение для future (из другого потока).
`std::condition_variable`	Условная переменная. Позволяет потоку ждать, пока другой поток не выполнит условие.

Создание потока

#include <iostream>
#include <thread>

// Функция, которую будет выполнять поток
void hello() {
    std::cout << "Привет из потока!" << std::endl;
}

int main() {
    // Создаем поток t, который выполняет функцию hello
    std::thread t(hello);

    // Главный поток продолжает работу
    std::cout << "Привет из главного потока!" << std::endl;

    // Ждем, пока поток t завершится (обязательно!)
    t.join();

    return 0;
}

Передача аргументов в поток

#include <iostream>
#include <thread>
#include <string>

void print_sum(int a, int b, const std::string& msg) {
    std::cout << msg << (a + b) << std::endl;
}

int main() {
    std::thread t(print_sum, 5, 3, "Сумма: ");
    t.join();
    return 0;
}

Использование лямбда-функций

#include <iostream>
#include <thread>

int main() {
    int x = 10;
    // Лямбда захватывает x по ссылке
    std::thread t([&x]() {
        x += 5;
        std::cout << "x в потоке: " << x << std::endl;
    });
    t.join();
    std::cout << "x в главном: " << x << std::endl; // 15
    return 0;
}

Мьютексы и защита данных

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx; // Глобальный мьютекс
int counter = 0;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        // Захватываем мьютекс. Если занят — ждем.
        mtx.lock();
        ++counter; // Критическая секция
        mtx.unlock(); // Обязательно отпускаем!
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter << std::endl; // 200000
    return 0;
}

Важно: Всегда используйте lock_guard вместо ручного lock/unlock. Если в критической секции возникнет исключение, unlock не вызовется, и программа зависнет (deadlock). lock_guard гарантирует unlock при любом выходе из блока.

lock_guard (безопасный вариант)

void increment_safe() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // Захват при создании
        ++counter;
    } // Автоматический unlock при разрушении lock
}

Асинхронность с std::async

#include <iostream>
#include <future>
#include <chrono>

// Долгая функция (скачивание файла)
int download_file() {
    std::this_thread::sleep_for(std::chrono::seconds(3)); // Имитация 3 секунд
    return 42; // Код возврата
}

int main() {
    std::cout << "Начинаем скачивание..." << std::endl;

    // Запускаем асинхронно. std::launch::async гарантирует выполнение в новом потоке.
    std::future<int> result = std::async(std::launch::async, download_file);

    // Пока файл скачивается, делаем другую работу
    std::cout << "Считаем что-то ещё..." << std::endl;
    for (int i = 0; i < 5; ++i) {
        std::cout << "Работаем... " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }

    // Получаем результат. Если задача ещё не завершена — ждем.
    int code = result.get();
    std::cout << "Скачивание завершено! Код: " << code << std::endl;

    return 0;
}

Примеры кода — от простого к сложному

Пример 1: Два потока, печатающих числа

#include <iostream>
#include <thread>

void print_numbers(int start, int end) {
    for (int i = start; i <= end; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main() {
    // Поток 1 печатает от 1 до 5
    std::thread t1(print_numbers, 1, 5);
    // Поток 2 печатает от 6 до 10
    std::thread t2(print_numbers, 6, 10);

    t1.join();
    t2.join();
    // Вывод может быть перемешан: 1 6 2 7 3 8 4 9 5 10
    return 0;
}

Объяснение: Два потока работают параллельно. Порядок вывода не гарантирован, так как std::cout не синхронизирован. Это демонстрирует отсутствие синхронизации.

Пример 2: Синхронизация с мьютексом

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print_numbers_safe(int start, int end) {
    std::lock_guard<std::mutex> lock(mtx); // Захватываем мьютекс
    for (int i = start; i <= end; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
} // Мьютекс автоматически отпускается

int main() {
    std::thread t1(print_numbers_safe, 1, 5);
    std::thread t2(print_numbers_safe, 6, 10);

    t1.join();
    t2.join();
    // Вывод будет строго: 1 2 3 4 5 
 6 7 8 9 10 
 (или наоборот)
    return 0;
}

Объяснение: Мьютекс гарантирует, что только один поток в момент времени печатает. Второй поток ждет, пока первый не закончит.

Пример 3: Атомарный счетчик

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0); // Атомарная переменная

void increment_atomic() {
    for (int i = 0; i < 100000; ++i) {
        counter++; // Атомарная операция — не нужен мьютекс
    }
}

int main() {
    std::thread t1(increment_atomic);
    std::thread t2(increment_atomic);
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter << std::endl; // Всегда 200000
    return 0;
}

Объяснение: std::atomic делает операции неделимыми. Это быстрее мьютекса для простых типов (int, bool, указатели).

Пример 4: Асинхронное чтение файла (симуляция)

#include <iostream>
#include <future>
#include <string>
#include <chrono>

// Симуляция чтения файла
std::string read_file_async(const std::string& filename) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // Долгая операция
    return "Содержимое файла " + filename;
}

int main() {
    std::cout << "Запрос на чтение файла..." << std::endl;

    // Запускаем асинхронное чтение
    std::future<std::string> file_content = std::async(std::launch::async, read_file_async, "data.txt");

    // Пока файл читается, делаем что-то полезное
    std::cout << "Выполняем другие вычисления..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // Получаем результат (ждем, если нужно)
    std::string content = file_content.get();
    std::cout << "Получено: " << content << std::endl;

    return 0;
}

Объяснение: std::async запускает задачу в отдельном потоке (или пуле потоков). future.get() блокирует поток, пока результат не будет готов. Это основа асинхронного программирования.

Пример 5: Пул потоков (ручная реализация)

#include <iostream>
#include <vector>
#include <thread>
#include <functional>
#include <queue>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task(); // Выполняем задачу
                }
            });
        }
    }

    void enqueue(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            tasks.push(std::move(task));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &worker : workers) {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;
};

int main() {
    ThreadPool pool(4); // 4 потока в пуле

    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i] {
            std::cout << "Задача " << i << " выполняется потоком " 
                      << std::this_thread::get_id() << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        });
    }

    // Деструктор pool дождется завершения всех задач
    return 0;
}

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

Пример 6: Deadlock (взаимная блокировка)

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx1, mtx2;

void thread_func1() {
    std::lock_guard<std::mutex> lock1(mtx1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Имитация работы
    std::lock_guard<std::mutex> lock2(mtx2); // Ждет mtx2
    std::cout << "Поток 1 завершен" << std::endl;
}

void thread_func2() {
    std::lock_guard<std::mutex> lock2(mtx2); // Захватили mtx2
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock1(mtx1); // Ждет mtx1
    std::cout << "Поток 2 завершен" << std::endl;
}

int main() {
    std::thread t1(thread_func1);
    std::thread t2(thread_func2);
    t1.join(); // Программа зависнет здесь!
    t2.join();
    return 0;
}

Объяснение: Поток 1 захватил mtx1 и ждет mtx2. Поток 2 захватил mtx2 и ждет mtx1. Они будут ждать друг друга вечно. Это deadlock. Решение: всегда захватывать мьютексы в одном и том же порядке.

Пример 7: Использование std::promise для передачи значения

#include <iostream>
#include <thread>
#include <future>

void set_value(std::promise<int>&& prom) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    prom.set_value(100); // Устанавливаем значение
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    std::thread t(set_value, std::move(prom)); // Передаем promise в поток

    std::cout << "Ожидаем значение..." << std::endl;
    int value = fut.get(); // Блокируемся, пока не получим значение
    std::cout << "Получено: " << value << std::endl;

    t.join();
    return 0;
}

Объяснение: std::promise и std::future — это пара для передачи данных между потоками. Один поток устанавливает значение через promise, другой получает его через future. Это безопасный способ обмена данными без глобальных переменных.

Сравнение с Python: чем похоже и чем отличается

Характеристика	C++	Python
Реальная многопоточность	Да. Потоки выполняются на разных ядрах реально параллельно.	Нет (GIL). Global Interpreter Lock не позволяет выполнять более одного потока в один момент времени (для CPU-bound задач). Для I/O-bound задач — да, работает.
Скорость создания потока	Быстро (на уровне ОС).	Медленнее (из-за накладных расходов Python).
Асинхронность	`std::async`, `std::future`. Требует ручного управления.	`asyncio` (async/await). Очень удобный синтаксис, встроенная поддержка.
Безопасность	Низкая. Легко получить гонку данных, deadlock. Требуется дисциплина.	Выше (GIL защищает от гонок данных для простых типов). Но deadlock тоже возможен.
Сложность	Высокая. Много подводных камней.	Средняя. asyncio проще для изучения.
Использование	Системное программирование, игры, высоконагруженные серверы.	Веб-скрапинг, API-серверы, автоматизация.

Совет: Если вам нужно ускорение вычислений (CPU-bound) — выбирайте C++ или Python с multiprocessing. Если много ожидания (I/O-bound) — Python с asyncio или C++ с std::async.

Типичные ошибки и подводные камни

Гонка данных (Data Race): Два потока одновременно пишут в одну переменную. Результат непредсказуем. Решение: Используйте мьютексы или атомарные переменные.
Deadlock (Взаимная блокировка): Потоки ждут друг друга. Решение: Всегда захватывайте мьютексы в одном порядке. Используйте std::lock для одновременного захвата нескольких мьютексов.
Забытый join() или detach(): Если не вызвать join() или detach() для потока, при разрушении объекта std::thread программа аварийно завершится (std::terminate).
Слишком много потоков: Создание 1000 потоков для 4 ядер приведет к огромным накладным расходам на переключение контекста. Решение: Используйте пул потоков с количеством потоков, равным числу ядер (std::thread::hardware_concurrency()).
Исключение в потоке: Если в потоке вылетит исключение, оно не поймается в главном потоке. Программа упадет. Решение: Оборачивайте тело потока в try-catch, либо используйте std::async — исключение сохранится в future и будет выброшено при вызове get().
Ложные пробуждения (spurious wakeup): condition_variable.wait() может проснуться без уведомления. Решение: Всегда используйте предикат (второй аргумент wait).
Захват по ссылке в лямбде: Если поток переживет переменную, на которую ссылается, будет обращение к освобожденной памяти. Решение: Передавайте аргументы по значению или используйте std::shared_ptr.

Лучшие практики и советы профессионалов

Избегайте разделяемого состояния. Лучший способ избежать проблем синхронизации — не иметь общих данных. Каждый поток работает со своей копией данных, а потом результаты объединяются (модель MapReduce).
Используйте высокоуровневые средства. std::async и std::future проще и безопаснее, чем ручное создание потоков. Для сложных задач используйте библиотеки Intel TBB или OpenMP.
Профилируйте. Не оптимизируйте многопоточность на глаз. Используйте профилировщики (Valgrind, perf) чтобы найти узкие места и гонки данных.
Документируйте гарантии. В комментариях указывайте, какие функции потокобезопасны, какие мьютексы защищают какие данные.
Используйте RAII. lock_guard, unique_lock — всегда. Никогда не вызывайте mtx.lock() вручную без необходимости.
Для I/O-bound задач — асинхронность, для CPU-bound — многопоточность. Не смешивайте без необходимости.
Тестируйте под нагрузкой. Гонки данных могут проявляться только при высокой нагрузке. Используйте ThreadSanitizer (флаг компилятора -fsanitize=thread) для обнаружения.

Вопросы для самопроверки

Вопрос: Что такое гонка данных (data race) и как её предотвратить?
Ответ: Это ситуация, когда два потока одновременно обращаются к одной переменной, и хотя бы один из них пишет. Предотвращается мьютексами или атомарными операциями.
Вопрос: В чем разница между std::thread и std::async?
Ответ: std::thread создает новый поток напрямую. std::async может использовать пул потоков и возвращает future для получения результата. async удобнее для асинхронных задач.
Вопрос: Что такое deadlock? Приведите пример.
Ответ: Ситуация, когда два потока ждут друг друга, захватив разные ресурсы. Пример: поток A захватил mtx1 и ждет mtx2, поток B захватил mtx2 и ждет mtx1.
Вопрос: Зачем нужен std::lock_guard вместо ручного lock/unlock?
Ответ: lock_guard гарантирует вызов unlock при любом выходе из блока (включая исключения). Это предотвращает deadlock из-за забытого unlock.
Вопрос: Что такое атомарная операция?
Ответ: Операция, которая выполняется за один неделимый шаг. Другие потоки не могут увидеть промежуточное состояние. В C++ реализуется через std::atomic.
Вопрос: Как узнать количество ядер процессора в C++?
Ответ: std::thread::hardware_concurrency(). Возвращает число аппаратных потоков (обычно равно числу ядер).
Вопрос: В чем отличие многопоточности от асинхронности?
Ответ: Многопоточность — это параллельное выполнение кода. Асинхронность — это запуск задачи и продолжение работы без ожидания её завершения. Асинхронность может быть реализована без многопоточности (например, через колбэки

← Предыдущая Паттерны проектирования в C++: подробное руководст Вперёд → Работа с сетью и HTTP API в C++: подробное руковод