c++多线程四种同步方式

在C++中，有多种方式可以实现多线程的同步。下面是四种常用的同步方式：

1. 互斥量（Mutex）：互斥量是一种基本的同步原语，用于保护共享资源免受并发访问的影响。线程在访问共享资源之前，需要先获取互斥量的锁，并在访问结束后释放锁，以确保每次只有一个线程可以访问共享资源。

   #include <mutex>
   
   std::mutex mtx;  // 定义互斥量
   
   void func()
   {
       std::lock_guard<std::mutex> lock(mtx);  // 获取互斥量的锁
       // 访问共享资源
       // ...
   }

3. 条件变量（Condition Variable）：条件变量用于在多线程环境中实现线程间的等待和通知机制。一个线程可以等待某个条件成立，而另一个线程在满足条件时发送信号通知等待线程继续执行。

   #include <mutex>
   #include <condition_variable>
   
   std::mutex mtx;
   std::condition_variable cv;
   bool condition = false;
   
   void waiting_thread()
   {
       std::unique_lock<std::mutex> lock(mtx);
       while (!condition)
       {
           cv.wait(lock);  // 等待条件变量
       }
       // 条件满足后执行操作
       // ...
   }
   
   void notifying_thread()
   {
       std::lock_guard<std::mutex> lock(mtx);
       condition = true;
       cv.notify_one();  // 发送信号通知等待线程
   }

5. 原子操作（Atomic）：原子操作是一种线程安全的操作，能够保证操作的原子性，不会被其他线程中断。原子操作可以用于对共享数据进行读取和更新，避免了锁的开销。

   #include <atomic>
   
   std::atomic<int> counter(0);
   
   void func()
   {
       counter.fetch_add(1);  // 原子增加操作
       // ...
   }

7. 信号量（Semaphore）：信号量是一种经典的同步原语，用于控制对共享资源的访问数量。线程可以通过信号量来请求访问资源，当资源可用时，线程可以继续执行；否则，线程将等待直到资源可用。

   #include <mutex>
   #include <condition_variable>
   
   class Semaphore
   {
   public:
       Semaphore(int count = 0) : count_(count) {}
   
       void acquire()
       {
           std::unique_lock<std::mutex> lock(mtx_);
           while (count_ == 0)
           {
               cv_.wait(lock);  // 等待信号量
           }
           --count_;
       }
   
       void release()
       {
           std::lock_guard<std::mutex> lock(mtx_);
           ++count_;
           cv_.notify_one();  // 发送信号通知等待线程
       }
   
   private:
       int count_;
       std::mutex mtx_;
       std::condition_variable cv_;
   };

这些同步方式在多线程编程中都起到了重要的作用，具体选择哪种方式取决于问题的需求和性能要求。