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

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

1. 互斥锁（Mutexes）: 互斥锁是最基本的同步机制，用于保护共享资源，确保同一时间只有一个线程可以访问。

   #include <mutex>
   #include <thread>
   
   std::mutex mtx; // 全局互斥锁
   
   void critical_section() {
       mtx.lock();
       // 访问共享资源
       mtx.unlock();
   }
   
   int main() {
       std::thread t1(critical_section);
       std::thread t2(critical_section);
   
       t1.join();
       t2.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, 5);
       t.join();
       return 0;
   }
   

3. 条件变量（Condition Variables）: 条件变量用于线程间的等待/通知机制，常与互斥锁一起使用。

   #include <mutex>
   #include <condition_variable>
   #include <thread>
   
   std::mutex mtx;
   std::condition_variable cv;
   bool ready = false;
   
   void wait_for_signal() {
       std::unique_lock<std::mutex> lock(mtx);
       cv.wait(lock, []{ return ready; });
       // 收到信号后的操作
   }
   
   void send_signal() {
       std::lock_guard<std::mutex> lock(mtx);
       ready = true;
       cv.notify_all();
   }
   
   int main() {
       std::thread waiter(wait_for_signal);
       std::thread notifier(send_signal);
   
       waiter.join();
       notifier.join();
   
       return 0;
   }
   

4. 读写锁（Read-Write Locks）: 当共享资源读取操作远多于写入操作时，可以使用读写锁来提高性能。

   #include <shared_mutex>
   #include <thread>
   
   std::shared_mutex rw_mtx;
   
   void read_resource() {
       std::shared_lock<std::shared_mutex> lock(rw_mtx);
       // 读取共享资源
   }
   
   void write_resource() {
       std::unique_lock<std::shared_mutex> lock(rw_mtx);
       // 写入共享资源
   }
   
   int main() {
       std::thread readers[5], writers[2];
   
       for (auto& r : readers) r = std::thread(read_resource);
       for (auto& w : writers) w = std::thread(write_resource);
   
       for (auto& r : readers) r.join();
       for (auto& w : writers) w.join();
   
       return 0;
   }
   

5. 原子操作（Atomic Operations）: 原子操作可以在不使用锁的情况下实现线程安全的操作。

   #include <atomic>
   #include <thread>
   
   std::atomic<int> counter(0);
   
   void increment_counter() {
       ++counter; // 原子操作
   }
   
   int main() {
       std::thread t1(increment_counter);
       std::thread t2(increment_counter);
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

6. 屏障（Barriers）: 屏障用于同步多个线程，确保它们都到达某个点后再继续执行。

   #include <barrier>
   #include <thread>
   #include <vector>
   
   std::barrier sync_point(3); // 创建一个屏障，等待3个线程
   
   void thread_work(int id) {
       // 执行一些工作
       sync_point.arrive_and_wait(); // 等待其他线程
       // 继续执行
   }
   
   int main() {
       std::vector<std::thread> threads;
   
       for (int i = 0; i < 3; ++i) {
           threads.emplace_back(thread_work, i);
       }
   
       for (auto& t : threads) {
           t.join();
       }
   
       return 0;
   }
   

在使用这些并发控制机制时，需要注意避免死锁和其他同步问题。正确地设计程序的并发模型对于构建高效且稳定的多线程应用程序至关重要。