Многопоточность в C++: std::thread и mutex

1#include <thread>
2#include <iostream>
3
4void worker(int id) {
5    std::cout << "Thread " << id << " started\n";
6    std::this_thread::sleep_for(std::chrono::milliseconds(100));
7    std::cout << "Thread " << id << " finished\n";
8}
9
10int main() {
11    std::thread t1(worker, 1);
12    std::thread t2(worker, 2);
13    
14    t1.join(); // Ожидание завершения
15    t2.join();
16    
17    return 0;
18}

1int main() {
2    int counter = 0;
3    std::mutex mtx;
4    
5    std::thread t1([&]() {
6        for (int i = 0; i < 1000; ++i) {
7            std::lock_guard<std::mutex> lock(mtx);
8            ++counter;
9        }
10    });
11    
12    std::thread t2([&]() {
13        for (int i = 0; i < 1000; ++i) {
14            std::lock_guard<std::mutex> lock(mtx);
15            ++counter;
16        }
17    });
18    
19    t1.join();
20    t2.join();
21    std::cout << "Counter: " << counter << "\n"; // 2000
22}

1class ThreadSafeCounter {
2    int count = 0;
3    mutable std::mutex mtx;
4public:
5    void increment() {
6        std::lock_guard<std::mutex> lock(mtx);
7        ++count;
8    }
9    
10    int get() const {
11        std::lock_guard<std::mutex> lock(mtx);
12        return count;
13    }
14};

1std::mutex mtx;
2std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
3
4// Теперь mutex не заблокирован
5lock.lock(); // Блокировка
6// ... работа ...
7lock.unlock(); // Ручная разблокировка
8lock.lock(); // Повторная блокировка

1#include <condition_variable>
2
3std::queue<int> tasks;
4std::mutex mtx;
5std::condition_variable cv;
6bool done = false;
7
8// Producer
9void producer() {
10    for (int i = 0; i < 10; ++i) {
11        {
12            std::lock_guard<std::mutex> lock(mtx);
13            tasks.push(i);
14        }
15        cv.notify_one();
16    }
17    {
18        std::lock_guard<std::mutex> lock(mtx);
19        done = true;
20    }
21    cv.notify_all();
22}
23
24// Consumer
25void consumer() {
26    while (true) {
27        std::unique_lock<std::mutex> lock(mtx);
28        cv.wait(lock, [] { return !tasks.empty() || done; });
29        
30        while (!tasks.empty()) {
31            int task = tasks.front();
32            tasks.pop();
33            lock.unlock();
34            // Обработка задачи
35            std::cout << "Processing: " << task << "\n";
36            lock.lock();
37        }
38        
39        if (done && tasks.empty()) break;
40    }
41}

1#include <atomic>
2
3std::atomic<int> counter{0};
4
5void increment() {
6    for (int i = 0; i < 1000; ++i) {
7        ++counter; // Атомарная операция
8    }
9}
10
11int main() {
12    std::thread t1(increment);
13    std::thread t2(increment);
14    t1.join();
15    t2.join();
16    std::cout << counter << "\n"; // 2000
17}

1#include <future>
2
3int compute() {
4    return 42;
5}
6
7int main() {
8    std::future<int> result = std::async(std::launch::async, compute);
9    // Другая работа...
10    int value = result.get(); // Блокирующее ожидание результата
11    std::cout << value << "\n";
12}