C++服务器端开发（7）:并发处理

并发处理的方式包括线程、互斥锁、条件变量和原子操作。

1.线程：C++11 引入了标准线程库，可以通过 std::thread 类来创建和管理线程。通过在不同的线程中执行不同的任务，可以实现并发处理。

#include <iostream>
#include <thread>

void foo()
{
    std::cout << "Thread 1" << std::endl;
}

void bar(int x)
{
    std::cout << "Thread 2: " << x << std::endl;
}

int main()
{
    std::thread t1(foo);
    std::thread t2(bar, 42);

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

    return 0;
}

2.互斥锁：C++11 中的 std::mutex 类提供了互斥锁的功能，可以用来保护共享资源，在多个线程中安全地访问和修改共享数据。

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

std::mutex mtx;

void func(int x)
{
    std::lock_guard<std::mutex> lock(mtx);

    std::cout << "Thread " << x << std::endl;
}

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

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

    return 0;
}

3.条件变量：C++11 中的 std::condition_variable 类用于线程之间的同步和通信。可以用条件变量来等待某个条件满足后再继续执行。

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker()
{
    {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return ready; });
        std::cout << "Thread 1" << std::endl;
    }
}

void signaler()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
}

int main()
{
    std::thread t1(worker);
    std::thread t2(signaler);

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

    return 0;
}

4.原子操作：C++11 中的 std::atomic 类用于实现原子操作，保证在多线程环境下对共享数据的操作是原子的，不会被其他线程打断。

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

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

void increment()
{
    for (int i = 0; i < 1000000; ++i)
    {
        counter.fetch_add(1);
    }
}

void decrement()
{
    for (int i = 0; i < 1000000; ++i)
    {
        counter.fetch_sub(1);
    }
}

int main()
{
    std::thread t1(increment);
    std::thread t2(decrement);

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

    std::cout << "Counter: " << counter << std::endl;

    return 0;
}