Как можно обмениваться информацией между потоками

1️⃣ Как кратко ответить

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

2️⃣ Подробное объяснение темы

В многопоточных приложениях часто возникает необходимость обмена данными между потоками. Это может быть необходимо для координации работы потоков, передачи результатов вычислений или обработки событий. В C++ для этого используются различные механизмы синхронизации и структуры данных.

Мьютексы (Mutexes)

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

#include <iostream>
#include <thread>
#include <mutex>
​
std::mutex mtx; // Создаем мьютекс
​
void print_message(const std::string& message) {
    mtx.lock(); // Захватываем мьютекс
    std::cout << message << std::endl; // Печатаем сообщение
    mtx.unlock(); // Освобождаем мьютекс
}
​
int main() {
    std::thread t1(print_message, "Hello from thread 1");
    std::thread t2(print_message, "Hello from thread 2");
​
    t1.join();
    t2.join();
​
    return 0;
}

• std::mutex mtx; — объявление мьютекса.
• mtx.lock(); и mtx.unlock(); — захват и освобождение мьютекса для обеспечения эксклюзивного доступа к std::cout.

Условные переменные (Condition Variables)

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

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
​
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
​
void wait_for_ready() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // Ожидаем, пока ready не станет true
    std::cout << "Thread is ready!" << std::endl;
}
​
void set_ready() {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one(); // Уведомляем один поток
}
​
int main() {
    std::thread t1(wait_for_ready);
    std::thread t2(set_ready);
​
    t1.join();
    t2.join();
​
    return 0;
}

• std::condition_variable cv; — объявление условной переменной.
• cv.wait(lock, []{ return ready; }); — поток ожидает, пока ready не станет true.
• cv.notify_one(); — уведомление одного потока о том, что условие выполнено.

Атомарные операции (Atomic Operations)

Атомарные операции позволяют выполнять операции над переменными без использования мьютексов, обеспечивая при этом их атомарность.

#include <iostream>
#include <thread>
#include <atomic>
​
std::atomic<int> counter(0); // Атомарная переменная
​
void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter; // Атомарное увеличение
    }
}
​
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
​
    t1.join();
    t2.join();
​
    std::cout << "Counter: " << counter << std::endl;
​
    return 0;
}

• std::atomic<int> counter(0); — объявление атомарной переменной.
• ++counter; — атомарное увеличение переменной counter.

Очереди сообщений (Message Queues)

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

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
​
std::queue<int> message_queue;
std::mutex mtx;
std::condition_variable cv;
​
void producer() {
    for (int i = 0; i < 10; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        message_queue.push(i); // Добавляем сообщение в очередь
        cv.notify_one(); // Уведомляем потребителя
    }
}
​
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !message_queue.empty(); }); // Ожидаем, пока очередь не станет непустой
        int message = message_queue.front();
        message_queue.pop(); // Извлекаем сообщение из очереди
        std::cout << "Consumed: " << message << std::endl;
        if (message == 9) break; // Завершаем, когда получено последнее сообщение
    }
}
​
int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
​
    t1.join();
    t2.join();
​
    return 0;
}

• std::queue<int> message_queue; — очередь для хранения сообщений.
• message_queue.push(i); — добавление сообщения в очередь.
• cv.wait(lock, []{ return !message_queue.empty(); }); — ожидание, пока очередь не станет непустой.
• message_queue.pop(); — извлечение сообщения из очереди.

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