• We've already mentioned that increment and potentially-blocking decrement are called signal and wait.
• Here's the reduced interface for our own semaphore class.

class semaphore {
 public:
  semaphore(int value = 0);
  void wait();
  void signal();

 private:
  int value;
  std::mutex m;
  std::condition_variable_any cv;

  semaphore(const semaphore& orig) = delete;
  const semaphore& operator=(const semaphore& rhs) const = delete;
};    

• You can use the semaphore by including the semaphore.h file.
  • All Makefiles are configured so that you can include it and link against its implementation. You can operate like it's a C++ built-in class.
  • You can look in /usr/class/cs110/local/include/semaphore.h to confirm it's really there. ☺

• By design, there's no getValue-like method!
  • Some semaphore designs provide such a method, but we do not.
  • Why omit it? In between the time you call it and act on it, some other thread could very well change it. Concurrency directives themselves shouldn't encourage anything that might lead to a race condition or a deadlock, so our version doesn't.
• Notice the three private data members are akin to the three global variables we introduced to limit the number of philosophers grabbing forks in the last version.
• I remove the copy constructor and assignment operator (using the delete keyword), because neither the mutex nor condition_variable_any are copy constructable, copy assignable, or even movable.
  • In a nutshell, this means you need to pass all instances of mutex, condition_variable_any, and semaphore around by reference or via its address.

• Here's the implementation of the constructor:

semaphore::semaphore(int value) : value(value), {}

• m and cv are zero-argument constructed.
• Data members are constructed in the order they appear in the class definition (not necessarily the order they appear in the initialization list).
• Here are the implementations of wait and signal, which look like our most recent implementations of waitForPermission and grantPermission:

void semaphore::wait() {
  lock_guard<mutex> lg(m);
  cv.wait(m, [this]{ return value > 0; });
  value--;
}

void semaphore::signal() {
  lock_guard<mutex> lg(m);
  value++;
  if (value == 1) cv.notify_all();
}

• Note that this needs to be captured by the on-the-fly predicate function we pass to cv.wait. We need access to the value data member, and capturing the address of the surrounding object allows this.
  • [&value] works with g++, but it's off C++11 specification and won't necessarily work with other compilers.