怎樣解決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++ 的資源競爭問題。在實際應用中，需要根據具體場景選擇合適的同步方法。