如何在Linux用C++实现并发控制

在Linux环境下用C++做并发控制，本质上就是和多线程打交道。C++11标准库已经把线程、锁、条件变量这些基础设施都塞进了语言核心，用起来比过去依赖POSIX线程那套API要顺手得多。不妨直接看几个典型场景，从创建线程到同步、通信、再到无锁操作，逐个拆解。

1. 头文件先行
   需要先拉进、、、这些基本依赖——哪个场景对应哪个，后文会逐一说明。

   #include 
   #include 
   #include 
   #include 

2. 创建线程，最简单的起手式
   用std::thread包裹一个可调用对象，调用.join()等待它结束。没什么花哨的，但必须养成习惯：每个thread对象最终要么join要么detach，否则析构时会直接调用std::terminate——这坑不少新手踩过。

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

3. 互斥锁：保护共享资源的标配
   当多个线程要写同一个变量（比如打印一条消息），数据竞争就来了。解决方案：一把std::mutex锁住临界区。用lock()/unlock()虽然直接，但更推荐用std::lock_guard或std::unique_lock——异常安全，不用操心手动解锁。

   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;
   }

4. 条件变量：让线程学会“等通知”
   有时候线程不能一直轮询标志位——太浪费CPU了。条件变量提供了阻塞+唤醒机制。下面这个例子启了10个线程，全都等一个ready标志变为true，然后主线程调用notify_all一次性唤醒它们。注意wait配合的unique_lock，以及第二个参数（谓词）防止虚假唤醒。

   #include 
   
   std::mutex mtx;
   std::condition_variable cv;
   bool ready = false;
   
   void printId(int id) {
       std::unique_lock lck(mtx);
       cv.wait(lck, []{ return ready; }); // 等待直到ready为true
       std::cout << "Thread " << id << std::endl;
   }
   
   void go() {
       std::lock_guard lck(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);
   
       std::cout << "10 threads ready to race..." << std::endl;
       go(); // 发令枪响
   
       for (auto &th : threads) th.join();
       return 0;
   }

5. 原子操作：无锁并发也靠谱
   如果只是对单个整型变量做加减，没必要上互斥锁——std::atomic给你更轻量的选择。下面两个线程各自对sharedValue加1000次，用fetch_add保证原子性，配合memory_order_relaxed（适合无依赖计数的场景）。最终结果一定是2000，不用锁也不用担心竞争。

   #include 
   
   std::atomic sharedValue(0);
   
   void incrementValue() {
       for (int i = 0; i < 1000; ++i) {
           sharedValue.fetch_add(1, std::memory_order_relaxed);
       }
   }
   
   int main() {
       std::thread t1(incrementValue);
       std::thread t2(incrementValue);
       t1.join();
       t2.join();
   
       std::cout << "Shared value: " << sharedValue.load() << std::endl;
       return 0;
   }

编译时要记得加上-pthread，否则链接会报错：

g++ -std=c++11 -pthread your_program.cpp -o your_program

以上这些例子基本覆盖了Linux下C++并发控制的主要招式：线程创建、互斥锁、条件变量、原子操作。实际开发中，需要根据场景权衡性能与复杂度——比如高频小数据用原子操作、长时间同步用条件变量、临界区长的操作依然离不开互斥锁。另外，死锁永远是个潜在的敌人，养成按固定顺序加锁或者使用std::scoped_lock的好习惯，能省去很多调试时间。