C++ Linux系统如何进行并发控制

在Linux系统中使用C++进行并发控制，通常会涉及到多线程编程。C++11引入了标准库中的线程支持，使得在C++中进行并发编程变得更加容易和安全。以下是一些基本的并发控制概念和方法：

1. 线程（std::thread）:
   C++11提供了std::thread类来创建和管理线程。你可以使用它来启动一个新的线程，并在该线程中执行函数或可调用对象。

   #include <iostream>
   #include <thread>
   
   void helloFunction() {
       std::cout << "Hello from a thread!" << std::endl;
   }
   
   int main() {
       std::thread t(helloFunction);
       t.join(); // 等待线程完成
       return 0;
   }
   

2. 互斥锁（std::mutex）:
   当多个线程需要访问共享资源时，使用互斥锁来确保同一时间只有一个线程可以访问该资源。

   #include <iostream>
   #include <thread>
   #include <mutex>
   
   std::mutex mtx; // 创建一个互斥锁
   
   void printMessage(const std::string& msg) {
       mtx.lock(); // 加锁
       std::cout << msg << std::endl;
       mtx.unlock(); // 解锁
   }
   
   int main() {
       std::thread t1(printMessage, "Hello from thread 1");
       std::thread t2(printMessage, "Hello from thread 2");
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

3. 锁（std::lock_guard, std::unique_lock）:
   std::lock_guard和std::unique_lock是RAII风格的锁管理类，它们在构造时自动加锁，在析构时自动解锁，这样可以避免忘记解锁导致的死锁问题。

   #include <iostream>
   #include <thread>
   #include <mutex>
   
   std::mutex mtx;
   
   void printMessage(const std::string& msg) {
       std::lock_guard<std::mutex> lock(mtx); // 自动管理锁
       std::cout << msg << std::endl;
   }
   
   int main() {
       // ... 同上
   }
   

4. 条件变量（std::condition_variable）:
   条件变量用于线程间的同步，它允许线程等待某个条件成立，或者通知其他线程某个条件已经成立。

   #include <iostream>
   #include <thread>
   #include <mutex>
   #include <condition_variable>
   
   std::mutex mtx;
   std::condition_variable cv;
   bool ready = false;
   
   void printId(int id) {
       std::unique_lock<std::mutex> lock(mtx);
       cv.wait(lock, []{ return ready; }); // 等待条件变量
       std::cout << "Thread " << id << std::endl;
   }
   
   void go() {
       std::lock_guard<std::mutex> lock(mtx);
       ready = true;
       cv.notify_all(); // 通知所有等待的线程
   }
   
   int main() {
       std::thread threads[10];
       // 创建多个线程
       for (int i = 0; i < 10; ++i) {
           threads[i] = std::thread(printId, i);
       }
       go(); // 改变条件并通知线程
       for (auto& th : threads) {
           th.join();
       }
       return 0;
   }
   

5. 原子操作（std::atomic）:
   对于简单的数据类型，可以使用std::atomic来保证操作的原子性，避免使用锁。

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

6. 信号量（semaphore）:
   Linux系统提供了POSIX信号量（sem_t），可以用于线程同步。

   #include <iostream>
   #include <thread>
   #include <semaphore.h>
   
   sem_t sem;
   
   void printMessage(const std::string& msg) {
       sem_wait(&sem); // 等待信号量
       std::cout << msg << std::endl;
       sem_post(&sem); // 发送信号量
   }
   
   int main() {
       sem_init(&sem, 0, 1); // 初始化信号量
   
       std::thread t1(printMessage, "Hello from thread 1");
       std::thread t2(printMessage, "Hello from thread 2");
   
       t1.join();
       t2.join();
   
       sem_destroy(&sem); // 销毁信号量
       return 0;
   }
   

在使用这些并发控制机制时，需要注意避免死锁、竞态条件和其他并发相关的问题。合理地设计程序结构和同步策略是编写高效且安全的多线程程序的关键。