c++分支如何进行并发控制

在C++中，可以使用多种方法进行分支并发控制。以下是一些建议：

1. 使用互斥锁（std::mutex）：互斥锁可以确保在同一时刻只有一个线程访问共享资源。当一个线程获得锁时，其他线程必须等待直到锁被释放。

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

std::mutex mtx;
int shared_resource = 0;

void thread_func(int id) {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock();
        shared_resource++;
        mtx.unlock();
    }
}

int main() {
    std::thread t1(thread_func, 1);
    std::thread t2(thread_func, 2);

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

    std::cout << "Shared resource: " << shared_resource << std::endl;

    return 0;
}

2. 使用原子操作（std::atomic）：原子操作是一种特殊的操作，它可以在不使用锁的情况下保证线程安全。原子操作是不可中断的，因此它们可以避免死锁和其他并发问题。

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

std::atomic<int> shared_resource(0);

void thread_func(int id) {
    for (int i = 0; i < 1000; ++i) {
        shared_resource++;
    }
}

int main() {
    std::thread t1(thread_func, 1);
    std::thread t2(thread_func, 2);

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

    std::cout << "Shared resource: " << shared_resource.load() << std::endl;

    return 0;
}

3. 使用条件变量（std::condition_variable）：条件变量可以用于线程间的同步，它们允许一个线程等待某个条件成立，而另一个线程在条件满足时通知等待的线程。

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

std::mutex mtx;
std::condition_variable cv;
int shared_resource = 0;
bool ready = false;

void thread_func(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });

    for (int i = 0; i < 1000; ++i) {
        shared_resource++;
    }
}

int main() {
    std::thread t1(thread_func, 1);
    std::thread t2(thread_func, 2);

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_all();

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

    std::cout << "Shared resource: " << shared_resource << std::endl;

    return 0;
}

这些方法可以根据具体需求进行组合使用，以实现更复杂的并发控制策略。