怎样解决Linux下C++的资源竞争问题

在 Linux 下，C++ 的资源竞争问题通常是由于多个线程同时访问共享资源而导致的

1. 使用互斥锁（Mutex）：

   互斥锁是一种同步机制，用于确保同一时间只有一个线程可以访问共享资源。在 C++ 中，可以使用 std::mutex 类来实现互斥锁。以下是一个简单的示例：

   #include <iostream>
   #include <thread>
   #include <mutex>
   
   std::mutex mtx; // 全局互斥锁
   
   void thread_func() {
       mtx.lock(); // 加锁
       // 访问共享资源
       std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
       mtx.unlock(); // 解锁
   }
   
   int main() {
       std::thread t1(thread_func);
       std::thread t2(thread_func);
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

2. 使用条件变量（Condition Variable）：

   条件变量是一种同步机制，用于在多个线程之间传递消息。在 C++ 中，可以使用 std::condition_variable 类来实现条件变量。以下是一个简单的示例：

   #include <iostream>
   #include <thread>
   #include <mutex>
   #include <condition_variable>
   
   std::mutex mtx; // 全局互斥锁
   std::condition_variable cv; // 全局条件变量
   bool ready = false; // 共享资源
   
   void thread_func() {
       std::unique_lock<std::mutex> lock(mtx); // 加锁
       cv.wait(lock, []{ return ready; }); // 等待条件满足
   
       // 访问共享资源
       std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
   
       ready = false; // 更新共享资源
       cv.notify_one(); // 通知其他线程
   }
   
   int main() {
       std::thread t1(thread_func);
       std::thread t2(thread_func);
   
       {
           std::lock_guard<std::mutex> lock(mtx); // 加锁
           ready = true; // 更新共享资源
       } // 解锁
   
       cv.notify_one(); // 通知其他线程
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

3. 使用原子操作（Atomic Operations）：

   原子操作是一种不可中断的操作，用于在多线程环境中安全地访问共享资源。在 C++11 及更高版本中，可以使用 std::atomic 类来实现原子操作。以下是一个简单的示例：

   #include <iostream>
   #include <thread>
   #include <atomic>
   
   std::atomic<bool> ready(false); // 全局原子变量
   
   void thread_func() {
       if (ready.exchange(true)) { // 原子地设置 ready 为 true
           // 访问共享资源
           std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
       } else {
           // 等待其他线程设置 ready 为 true
           while (!ready.load()) {
               std::this_thread::yield();
           }
       }
   }
   
   int main() {
       std::thread t1(thread_func);
       std::thread t2(thread_func);
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

通过使用这些同步机制，可以有效地解决 Linux 下 C++ 的资源竞争问题。在实际应用中，需要根据具体场景选择合适的同步方法。