Linux C++开发中如何进行并发编程

在 Linux 中进行 C++ 并发编程，你可以使用以下方法：

1. 使用多线程（pthread）库：

   pthread 是 Linux 下最常用的多线程库。要使用 pthread，首先需要包含头文件 pthread.h。然后，你可以创建线程、设置线程属性、线程同步等。

   下面是一个简单的 pthread 示例：

   #include <iostream>
   #include <pthread.h>
   
   void* print_hello(void* arg) {
       std::cout << "Hello from thread " << pthread_self() << std::endl;
       return nullptr;
   }
   
   int main() {
       pthread_t threads[5];
       int rc;
   
       for (int i = 0; i < 5; ++i) {
           rc = pthread_create(&threads[i], nullptr, print_hello, nullptr);
           if (rc != 0) {
               std::cerr << "Error creating thread "<< i << std::endl;
               return 1;
           }
       }
   
       for (int i = 0; i < 5; ++i) {
           pthread_join(threads[i], nullptr);
       }
   
       return 0;
   }
   

2. 使用 C++11 标准库中的线程（std::thread）：

   C++11 引入了线程库，它提供了一种更简洁的方法来实现多线程编程。要使用 std::thread，首先需要包含头文件 <thread>。然后，你可以创建线程、设置线程属性、线程同步等。

   下面是一个简单的 std::thread 示例：

   #include <iostream>
   #include <thread>
   
   void print_hello() {
       std::cout << "Hello from thread " << std::this_thread::get_id() << std::endl;
   }
   
   int main() {
       std::thread threads[5];
   
       for (int i = 0; i < 5; ++i) {
           threads[i] = std::thread(print_hello);
       }
   
       for (auto& t : threads) {
           t.join();
       }
   
       return 0;
   }
   

3. 使用互斥锁（std::mutex）进行线程同步：

   当多个线程访问共享资源时，可能会导致数据竞争和不一致。为了避免这种情况，可以使用互斥锁（std::mutex）来确保同一时间只有一个线程访问共享资源。

   下面是一个简单的 std::mutex 示例：

   #include <iostream>
   #include <thread>
   #include <mutex>
   
   std::mutex mtx;
   int counter = 0;
   
   void increment() {
       std::unique_lock<std::mutex> lock(mtx);
       ++counter;
       lock.unlock();
   }
   
   int main() {
       std::thread threads[10];
   
       for (int i = 0; i < 10; ++i) {
           threads[i] = std::thread(increment);
       }
   
       for (auto& t : threads) {
           t.join();
       }
   
       std::cout << "Counter: " << counter << std::endl;
   
       return 0;
   }
   

4. 使用条件变量（std::condition_variable）进行线程同步：

   条件变量允许线程等待某个条件成立。当条件满足时，线程将被唤醒。条件变量通常与互斥锁一起使用。

   下面是一个简单的 std::condition_variable 示例：

   #include <iostream>
   #include <thread>
   #include <mutex>
   #include <condition_variable>
   
   std::mutex mtx;
   std::condition_variable cv;
   bool ready = false;
   
   void print_ready_message() {
       std::unique_lock<std::mutex> lock(mtx);
       while (!ready) {
           cv.wait(lock);
       }
       std::cout << "Ready!" << std::endl;
   }
   
   void set_ready() {
       std::unique_lock<std::mutex> lock(mtx);
       ready = true;
       cv.notify_one();
   }
   
   int main() {
       std::thread t1(print_ready_message);
       std::thread t2(set_ready);
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

这些只是 Linux C++ 并发编程的基本概念。在实际项目中，你可能需要根据需求选择合适的并发编程方法，并处理更复杂的同步和通信问题。