semaphore.h

 
#ifndef CTRL_UTILS_SEMAPHORE_H_
#define CTRL_UTILS_SEMAPHORE_H_
 
#include <condition_variable>  // std::condition_variable
#include <mutex>               // std::mutex, std::unique_lock
 
namespace std {
 
class binary_semaphore {
 public:
  explicit binary_semaphore(bool desired) : val_(desired) {}
 
  inline void acquire() {
    std::unique_lock<std::mutex> lock(m_);
    cv_.wait(lock, [this]() { return val_; });
    val_ = false;
  }
 
  bool try_acquire() {
    std::unique_lock<std::mutex> try_lock(m_, std::try_to_lock);
    if (!try_lock) return false;
    val_ = false;
    return true;
  }
 
  inline void release() {
    std::unique_lock<std::mutex> lock(m_);
    val_ = true;
    lock.unlock();
    cv_.notify_one();
  }
 
 private:
  std::condition_variable cv_;
  std::mutex m_;
  bool val_ = false;
};
 
class counting_semaphore {
 public:
  explicit counting_semaphore(ptrdiff_t desired) : val_(desired) {}
 
  inline void acquire() {
    std::unique_lock<std::mutex> lock(m_);
    cv_.wait(lock, [this]() { return val_ > 0; });
    --val_;
  }
 
  bool try_acquire() {
    std::unique_lock<std::mutex> try_lock(m_, std::try_to_lock);
    if (!try_lock) return false;
    --val_;
    return true;
  }
 
  inline void release() {
    std::unique_lock<std::mutex> lock(m_);
    ++val_;
    lock.unlock();
    cv_.notify_one();
  }
 
 private:
  std::condition_variable cv_;
  std::mutex m_;
  ptrdiff_t val_ = 0;
};
 
}  // namespace std
 
#endif  // CTRL_UTILS_SEMAPHORE_H_