Concepto de bloqueos de lectura/escritura en C++

1. Propósito y usos de los bloqueos de lector/escritor
2. Pasos para implementar bloqueos de lector/escritor en C++

Un bloqueo de lector/escritor es un mecanismo de sincronización que permite que los subprocesos adquieran el bloqueo de lectura o escritura para que un subproceso no bloquee el acceso de otro al recurso mientras se modifica.

A menudo se utilizan para implementar estructuras de datos compartidos de solo lectura, como una memoria caché global o tabla de búsqueda. El bloqueo de lector/escritor se puede implementar utilizando variables de condición o mutexes.

Propósito y usos de los bloqueos de lector/escritor

Los bloqueos del lector se utilizan cuando el lector no puede cambiar los datos. El bloqueo de escritor se utiliza cuando un escritor desea acceso exclusivo para modificar datos.

Los bloqueos de lector también se denominan bloqueos de “solo lectura” y se encuentran a menudo en sistemas multiusuario. Permiten que uno o más lectores accedan a los datos sin afectarlos, mientras que un escritor solo puede cambiar los datos si tiene acceso exclusivo a ellos.

Por otro lado, los bloqueos de escritor se utilizan cuando solo una persona necesita poder escribir cambios en un archivo a la vez. Esto evita la escritura simultánea y asegura que no haya conflicto entre las actualizaciones realizadas por diferentes personas en diferentes momentos.

Pasos para implementar bloqueos de lector/escritor en C++

En C++, los bloqueos de lector/escritor se pueden implementar en unos pocos pasos.

1. Primero, el bloqueo debe inicializarse con un shared_ptr para el recurso protegido por el bloqueo.
2. En segundo lugar, se debe crear una función para adquirir y liberar el bloqueo cuando sea necesario.
3. En tercer lugar, las funciones de adquirir y liberar deben llamarse en los momentos apropiados.
4. En cuarto lugar, se debe crear una función que verifique si hay otros subprocesos esperando el mismo recurso que ya lo tiene y, de ser así, esperar hasta que lo hayan liberado antes de volver a adquirirlo.
5. En quinto lugar, llame a esta función desde las funciones adquirir y liberar del paso dos.

Ejemplo:

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

using namespace std;

class demo {
 public:
  void sam() {
    unique_lock lock(mutex_);
    ++b;
  }

  unsigned int get() {
    shared_lock lock(mutex_);
    return b;
  }

 private:
  mutable shared_mutex mutex_;
  unsigned int b = 0;
};

int main() {
  demo tbh;

  auto sam_and_roi = [&tbh]() {
    for (int x = 0; x < 6; x++) {
      tbh.sam();
      cout << this_thread::get_id() << tbh.get() << '\n';
    }
  };

  thread start(sam_and_roi);
  start.join();
}

Haga clic aquí para verificar el funcionamiento del ejemplo como se mencionó anteriormente.