在Linux下使用C++实现并发控制，可以采用多种方法。以下是一些常用的并发控制机制：
互斥锁（Mutexes）: 互斥锁是最基本的同步机制，用于确保多个线程不会同时访问共享资源。
#include <mutex> #include <thread> 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 th1(print_block, 50, '*'); std::thread th2(print_block, 50, '$'); th1.join(); th2.join(); return 0; } 递归互斥锁（Recursive Mutexes）: 如果一个线程需要多次获取同一个互斥锁，可以使用递归互斥锁。
#include <mutex> #include <thread> std::recursive_mutex rmtx; void recursive_function(int n) { if (n <= 0) return; rmtx.lock(); recursive_function(n - 1); rmtx.unlock(); } int main() { std::thread t(recursive_function, 10); t.join(); return 0; } 条件变量（Condition Variables）: 条件变量允许线程等待某个条件成立，或者通知其他线程某个条件已经成立。
#include <condition_variable> #include <mutex> #include <thread> #include <iostream> std::mutex mtx; std::condition_variable cv; bool ready = false; void print_id(int id) { std::unique_lock<std::mutex> lck(mtx); cv.wait(lck, []{return ready;}); // 等待直到ready为true std::cout << "Thread " << id << '\n'; } void go() { std::lock_guard<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_id, i); std::cout << "10 threads ready to race...\n"; go(); // go! for (auto &th : threads) th.join(); return 0; } 原子操作（Atomic Operations）: 原子操作可以保证操作的原子性，不需要额外的同步机制。
#include <atomic> #include <thread> #include <iostream> std::atomic<int> counter(0); void increment_counter() { for (int i = 0; i < 100000; ++i) { counter.fetch_add(1, std::memory_order_relaxed); } } int main() { std::thread t1(increment_counter); std::thread t2(increment_counter); t1.join(); t2.join(); std::cout << "Counter: " << counter.load() << '\n'; return 0; } 读写锁（Read-Write Locks）: 当共享资源读取操作远多于写入操作时，可以使用读写锁来提高性能。
#include <shared_mutex> #include <thread> #include <vector> class SharedData { public: void read() const { std::shared_lock<std::shared_mutex> lock(rw_mtx); // 执行读操作 } void write() { std::unique_lock<std::shared_mutex> lock(rw_mtx); // 执行写操作 } private: mutable std::shared_mutex rw_mtx; // 共享数据 }; int main() { SharedData data; std::vector<std::thread> threads; // 创建多个读线程 for (int i = 0; i < 10; ++i) { threads.emplace_back([&data]{ data.read(); }); } // 创建写线程 threads.emplace_back([&data]{ data.write(); }); // 等待所有线程完成 for (auto& th : threads) { th.join(); } return 0; } 信号量（Semaphores）: 信号量是一种更高级的同步机制，可以用来控制对资源的访问。
#include <semaphore> #include <thread> #include <iostream> std::binary_semaphore sem(1); // 二进制信号量，初始值为1 void critical_section() { sem.acquire(); // 获取信号量 // 访问临界区 std::cout << "In critical section\n"; sem.release(); // 释放信号量 } int main() { std::thread t1(critical_section); std::thread t2(critical_section); t1.join(); t2.join(); return 0; } 在使用这些并发控制机制时，需要注意避免死锁、竞态条件等问题。合理地设计程序结构和同步策略是实现高效并发的关键。
