信号量（Semaphore）是一种同步机制，用于管理共享资源的访问。通常，它被用来控制同时访问一个共享资源的进程或线程个数。在 C++ 中，我们可以使用多线程实现信号量的功能。本文将介绍如何使用 C++ 多线程实现信号量。

在 C++ 中，我们可以使用 mutex 和 condition_variable 实现信号量。mutex 是 C++ 中的互斥锁，用于保护共享资源。condition_variable 用于通知等待它的线程。

首先，我们需要定义一个 Semaphore 类。Semaphore 类中包含了一个 mutex 和一个 condition_variable：

class Semaphore {
public:
  Semaphore(int count = 0) : count_(count) {}
  void Notify() {
    std::unique_lock<std::mutex> lock(mutex_);
    ++count_;
    cv_.notify_one();
  }
  void Wait() {
    std::unique_lock<std::mutex> lock(mutex_);
    cv_.wait(lock, [this] return count_ > 0; );
    --count_;
  }
private:
  std::mutex mutex_;
  std::condition_variable cv_;
  int count_;
};

下面，我们来解释一下 Semaphore 类中的函数。

Notify() 函数用于释放一个信号。它会增加 count_ 的值，并且通知正在等待的线程（如果有的话）。

Wait() 函数用于等待一个信号，等待结束后，它会减少 count_ 的值。

使用 Semaphore 类时，我们需要创建一个 Semaphore 对象，并设置初始 count_ 值。

下面的示例代码展示了 Semaphore 类的使用：

#include <iostream>
#include <thread>
#include <chrono>
Semaphore semaphore(3);
void worker() {
  semaphore.Wait();
  std::cout << "Thread " << std::this_thread::get_id() << " is working." << std::endl;
  std::this_thread::sleep_for(std::chrono::seconds(2));
  semaphore.Notify();
}
int main() {
  std::thread workers[5];
  for (int i = 0; i < 5; ++i) {
    workers[i] = std::thread(worker);
  }
  for (int i = 0; i < 5; ++i) {
    workers[i].join();
  }
  return 0;
}

在上面的示例代码中，我们创建了 5 个线程，并定义一个 Semaphore 对象 semaphore。在每个线程中，我们调用了 semaphore.Wait()，以等待一个信号。当获取到信号后，线程会输出当前的线程 ID，并且休眠 2 秒。在休眠结束后，线程使用 semaphore.Notify() 释放信号。

由于 Semaphore 对象初始 count_ 值为 3，所以只有前三个线程可以获取到信号，并执行它们的任务。剩下的两个线程会等待信号的释放。

在信号量的实现中，Wait() 函数使用了 condition_variable 的 wait() 函数，以等待信号的到来。当 Wait() 函数返回时，它会减少 count_ 的值，表示使用了一个信号。

Notify() 函数使用了 condition_variable 的 notify_one() 函数，以通知正在等待的线程。

总结一下，本文介绍了如何使用 C++ 多线程实现信号量功能。通过使用 Semaphore 类，我们可以实现对共享资源的访问控制，以保证正确性和效率。

相似文章

友情链接
• 网站定制开发
• 帮你发
• 小蓄群站获客
• 雅圣洁家政