Linux下C++如何实现并发控制

在Linux下使用C++实现并发控制，可以采用多种方法。以下是一些常用的并发控制机制：

1. 互斥锁（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;
   }
   

2. 递归互斥锁（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;
   }
   

3. 条件变量（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;
   }
   

4. 原子操作（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;
   }
   

5. 读写锁（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;
   }
   

6. 信号量（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;
   }
   

在使用这些并发控制机制时，需要注意避免死锁、竞态条件等问题。合理地设计程序结构和同步策略是实现高效并发的关键。