C++ 多线程同步

在C++中，多线程同步是非常重要的，因为多个线程同时访问共享资源可能会导致数据竞争和不一致性。以下是一些常见的多线程同步机制：

互斥锁：互斥锁是一种最基本的同步机制，它可以保证同一时间只有一个线程可以访问共享资源。当一个线程获得了互斥锁，其他线程就必须等待该线程释放锁后才能访问共享资源。

条件变量：条件变量是一种同步机制，它可以让线程在满足某个条件时等待，而不是忙等待。条件变量通常与互斥锁一起使用，当条件不满足时，线程会释放互斥锁并等待条件变量，当条件满足时，线程会重新获得互斥锁并继续执行。

信号量：信号量是一种同步机制，它可以控制多个线程对共享资源的访问。信号量有一个计数器，当计数器为0时，线程会被阻塞，当计数器大于0时，线程可以访问共享资源并将计数器减1。

屏障：屏障是一种同步机制，它可以让多个线程在某个点上等待，直到所有线程都到达该点后才继续执行。屏障通常用于分阶段的任务，每个阶段都需要等待所有线程完成后才能进入下一阶段。

以上是一些常见的多线程同步机制，不同的场景需要选择不同的同步机制来保证线程安全和正确性。

下面详细介绍，并写出例子

1. 互斥锁（mutex）

互斥锁是一种最基本的同步机制，它可以保证同一时间只有一个线程访问共享资源。在C++中，可以使用std::mutex来实现互斥锁。

```c++
#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print(int num) {

    mtx.lock();
    std::cout << "Thread " << num << " is printing." << std::endl;
    mtx.unlock();
}

int main() {

    std::thread t1(print, 1);
    std::thread t2(print, 2);
    t1.join();
    t2.join();
    return 0;
}
```

2. 条件变量（condition variable）

条件变量是一种高级的同步机制，它可以让线程在某个条件满足时才继续执行。在C++中，可以使用std::condition_variable来实现条件变量。

```c++
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

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

void print(int num) {

    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) {

        cv.wait(lock);
    }
    std::cout << "Thread " << num << " is printing." << std::endl;
}

int main() {

    std::thread t1(print, 1);
    std::thread t2(print, 2);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    ready = true;
    cv.notify_all();
    t1.join();
    t2.join();
    return 0;
}
```

3. 信号量（semaphore）

信号量是一种常用的同步机制，它可以控制同时访问共享资源的线程数量。在C++中，可以使用std::semaphore来实现信号量。

```c++
#include <iostream>
#include <thread>
#include <semaphore.h>

sem_t sem;

void print(int num) {

    sem_wait(&sem);
    std::cout << "Thread " << num << " is printing." << std::endl;
    sem_post(&sem);
}

int main() {

    sem_init(&sem, 0, 1);
    std::thread t1(print, 1);
    std::thread t2(print, 2);
    t1.join();
    t2.join();
    sem_destroy(&sem);
    return 0;
}
```

4. 屏障（barrier）

屏障是一种同步机制，它可以让多个线程在某个点上等待，直到所有线程都到达这个点后才继续执行。在C++中，可以使用std::barrier来实现屏障。

```c++
#include <iostream>
#include <thread>
#include <barrier>

std::barrier bar(2);

void print(int num) {

    std::cout << "Thread " << num << " is waiting." << std::endl;
    bar.wait();
    std::cout << "Thread " << num << " is printing." << std::endl;
}

int main() {

    std::thread t1(print, 1);
    std::thread t2(print, 2);
    t1.join();
    t2.join();
    return 0;
}