0Pricing
C++ Academy · Lección

std::mutex, lock_guard y unique_lock

Proteja el estado compartido con mutexes y ayudantes de bloqueo basados en RAII.

std::mutex, lock_guard y unique_lock es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

Por qué usar un mutex

Cuando varios hilos acceden a los mismos datos, compiten por ellos. Un mutex garantiza la exclusión mutua: solo un hilo puede mantener el bloqueo a la vez.

Conceptos básicos de std::mutex

Construir, bloquear y desbloquear. El bloqueo manual es propenso a errores; use siempre ayudantes RAII.

#include <mutex>
std::mutex mtx;

mtx.lock();
// critical section
mtx.unlock();

std::lock_guard: bloqueo RAII

Es el bloqueo RAII más sencillo. Bloquea en el constructor y desbloquea en el destructor. Funciona perfectamente para secciones críticas que no lanzan excepciones.

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

std::scoped_lock (C++17)

Es similar a lock_guard, pero puede bloquear varios mutexes a la vez sin provocar interbloqueos. Prefiéralo en el código moderno.

#include <mutex>
std::scoped_lock lock(mtx1, mtx2, mtx3);  // locks all atomically

std::unique_lock: bloqueo flexible

Ofrece más funcionalidades que lock_guard:

  • Se puede desbloquear y volver a bloquear durante el ámbito
  • Se puede mover, transfiriendo la propiedad
  • Se usa con variables de condición
std::unique_lock<std::mutex> lock(mtx);
lock.unlock();        // release temporarily
// ... do something without the lock ...
lock.lock();           // reacquire

Cómo evitar interbloqueos

Dos hilos pueden entrar en un interbloqueo si adquieren los bloqueos en órdenes distintos. Adquiera los bloqueos siguiendo un orden global coherente o use std::scoped_lock con varios mutexes.

std::lock para varios mutexes

Antes de C++17, use std::lock para adquirir varios mutexes atómicamente. En C++17, std::scoped_lock resulta más claro.

Mutex recursivo

std::recursive_mutex permite que un hilo lo bloquee varias veces. Normalmente es señal de problemas de diseño; en su lugar, refactorice el código.

try_lock y timed_mutex

try_lock devuelve el control inmediatamente si el mutex está bloqueado. std::timed_mutex admite intentos de bloqueo con un límite de tiempo.

Bloqueo de lectura y escritura

std::shared_mutex (C++17) permite muchos lectores simultáneos o un único escritor exclusivo. Úselo en cargas de trabajo con predominio de lecturas.

std::shared_mutex sm;
void read()  { std::shared_lock lk(sm);   /* read */ }
void write() { std::unique_lock lk(sm);   /* write */ }

Equilibrio de granularidad

Bloquear de forma demasiado general perjudica la concurrencia. Bloquear de forma demasiado específica añade sobrecoste. Mida el rendimiento y ajuste.

Alternativas sin bloqueo

En situaciones de alta contención, considere estructuras de datos sin bloqueo, como atómicos y colas sin bloqueo. Son mucho más difíciles de escribir correctamente; úselas solo cuando sea necesario y después de verificarlas.

Comprobación rápida

¿Qué bloqueo RAII debería preferir al bloquear varios mutexes a la vez?

Resumen

Use std::lock_guard para secciones críticas sencillas, std::scoped_lock para varios mutexes y std::unique_lock cuando necesite flexibilidad, como con variables de condición o desbloqueo manual. Use siempre RAII; nunca llame manualmente a lock o unlock.

Preguntas frecuentes

¿La lección «std::mutex, lock_guard y unique_lock» es gratis?

Sí — el texto completo de «std::mutex, lock_guard y unique_lock» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «std::mutex, lock_guard y unique_lock»?

Proteja el estado compartido con mutexes y ayudantes de bloqueo basados en RAII. Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «std::mutex, lock_guard y unique_lock»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Unión y separación de std::thread
  2. std::mutex, lock_guard y unique_lock
  3. Variables de condición y patrones de trabajadores
  4. Conceptos básicos de std::async y std::future
← Volver a C++ Academy