同步两个线程通常意味着确保它们在某个特定的点上或者操作上能够协调一致。在C++中，可以使用多种同步机制来同步线程，以下是一些常用的方法：

1. 使用互斥锁（Mutex）

互斥锁是一种最常见的同步机制，它可以确保同一时间只有一个线程可以访问某个资源。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx; // 创建互斥锁void print_block(int n, char c) {mtx.lock(); // 加锁for (int i = 0; i < n; ++i) { std::cout << c; }std::cout << '\n';mtx.unlock(); // 解锁
}int main() {std::thread t1(print_block, 50, '*');std::thread t2(print_block, 50, '$');t1.join();t2.join();return 0;
}

2. 使用锁_guard（Lock_guard）

std::lock_guard 是一个作用域锁，它在构造时自动加锁，并在析构时自动解锁，这样可以防止忘记解锁。

void print_block(int n, char c) {std::lock_guard<std::mutex> guard(mtx); // 创建作用域锁for (int i = 0; i < n; ++i) { std::cout << c; }std::cout << '\n';
}

3. 使用条件变量（Condition Variable）

条件变量可以用来阻塞线程，直到某个条件成立。它们通常与互斥锁一起使用。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable cv;
bool ready = false;void print_block(int n, char c) {std::unique_lock<std::mutex> lck(mtx);cv.wait(lck, []{return ready;}); // 等待条件变量for (int i = 0; i < n; ++i) { std::cout << c; }std::cout << '\n';
}void go() {std::unique_lock<std::mutex> lck(mtx);ready = true;cv.notify_all(); // 通知所有等待的线程
}int main() {std::thread threads[10];// spawn 10 threads:for (int i = 0; i < 10; ++i)threads[i] = std::thread(print_block, 50, '0' + i);std::cout << "10 threads ready to race...\n";go(); // go!for (auto& th : threads) th.join();return 0;
}

4. 使用原子操作（Atomic Operations）

对于简单的同步任务，可以使用原子操作来保证数据的一致性，而不需要使用互斥锁。

#include <atomic>
#include <thread>
#include <iostream>std::atomic<bool> ready(false);void thread1() {while (!ready) { /* spin */ }std::cout << "Thread 1: ready is now true.\n";
}void thread2() {ready = true;std::cout << "Thread 2: ready is now true.\n";
}int main() {std::thread t1(thread1);std::thread t2(thread2);t1.join();t2.join();return 0;
}