std::shared_mutex

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
 
class ThreadSafeCounter {
 public:
  ThreadSafeCounter() = default;
 
  // Múltiples hilos/lectores pueden leer el valor del contador al mismo tiempo.
  unsigned int get() const {
    std::shared_lock lock(mutex_);
    return value_;
  }
 
  // Solo un hilo/escritor puede incrementar/escribir el valor del contador.
  unsigned int increment() {
    std::unique_lock lock(mutex_);
    return ++value_;
  }
 
  // Solo un hilo/escritor puede restablecer/escribir el valor del contador.
  void reset() {
    std::unique_lock lock(mutex_);
    value_ = 0;
  }
 
 private:
  mutable std::shared_mutex mutex_;
  unsigned int value_ = 0;
};
 
int main() {
  ThreadSafeCounter counter;
 
  auto increment_and_print = [&counter]() {
    for (int i = 0; i < 3; i++) {
      std::cout << std::this_thread::get_id() << ' ' << counter.increment() << '\n';
 
      // Nota: Escribir a std::cout de hecho también necesita sincronizarse
      // por otro std::mutex. Se ha omitido para hacer corto el ejemplo.
    }
  };
 
  std::thread thread1(increment_and_print);
  std::thread thread2(increment_and_print);
 
  thread1.join();
  thread2.join();
}
 
// Explicación: El resultado a continuación se generó en una máquina de un solo
// núcleo. Cuando thread1 comienza, ingresa al bucle por primera vez y llama a
// increment() seguido de get(). Sin embargo, antes de que pueda imprimir el
// valor devuelto a std::cout, el programador pone a thread1 en suspensión y
// despierta a thread2, que obviamente, tiene tiempo suficiente para ejecutar
// las tres iteraciones del bucle a la vez. De regreso a thread1, aún en la
// primera iteración del ciclo, finalmente imprime su copia local del valor del
// contador, que es 1, a std::cout y luego ejecuta las dos iteraciones restantes
// del bucle. En una máquina de varios núcleos, ninguno de los hilos se coloca en
// modo de suspensión y es más probable que la salida esté en orden ascendente.