0Pricing
Go Academy · Lección

sync.Mutex y sync.RWMutex

Patrones de bloqueo y de bloqueo para lectura y escritura

sync.Mutex y sync.RWMutex es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 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 Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Por qué utilizar mutexes?

Cuando varias goroutines comparten un estado mutable, las lecturas y escrituras simultáneas provocan condiciones de carrera. Un mutex serializa el acceso para que solo una goroutine entre en la sección crítica cada vez.

Conceptos básicos de sync.Mutex

Bloquee antes de leer o escribir el estado compartido y desbloquee después. Utilice defer para garantizar el desbloqueo incluso si la función provoca un panic.

var mu sync.Mutex
var counter int

func inc() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

Incrustar un Mutex en una estructura

Incruste el mutex en la estructura que protege. Por convención, el mutex se declara justo encima de los campos que protege.

type SafeCounter struct {
    mu sync.Mutex
    v  map[string]int
}
func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.v[key]++
}

No copie un Mutex

No se debe copiar un Mutex después de su primer uso. Páselo mediante un puntero o incrústelo en una estructura que se pase mediante un puntero. La herramienta go vet detecta las copias.

sync.RWMutex

sync.RWMutex permite varios lectores simultáneos, pero solo un escritor. Utilícelo cuando predominen las lecturas y las escrituras sean poco frecuentes para aumentar el rendimiento.

var rw sync.RWMutex
var data map[string]int

func read(k string) int {
    rw.RLock()
    defer rw.RUnlock()
    return data[k]
}
func write(k string, v int) {
    rw.Lock()
    defer rw.Unlock()
    data[k] = v
}

RLock frente a Lock

RLock adquiere un bloqueo de lectura (compartido); Lock adquiere un bloqueo de escritura (exclusivo). Un bloqueo de escritura pendiente impide nuevos bloqueos de lectura y evita la inanición del escritor.

TryLock (Go 1.18+)

mu.TryLock() adquiere el bloqueo solo si está libre en ese momento y devuelve un booleano. Es útil cuando no se puede permitir el bloqueo.

if mu.TryLock() {
    defer mu.Unlock()
    // critical section
}

Interbloqueos

Se produce un interbloqueo cuando la goroutine A mantiene el bloqueo 1 mientras espera el bloqueo 2, y la goroutine B mantiene el bloqueo 2 mientras espera el bloqueo 1. Adquiera siempre los bloqueos en el mismo orden y mantenga breves las secciones críticas.

Granularidad de los bloqueos

Un bloqueo de grano grueso es más fácil de analizar, pero reduce la concurrencia. Los bloqueos de grano fino mejoran el rendimiento, pero aumentan la complejidad y el riesgo de interbloqueos. Comience con un bloqueo de grano grueso y optimícelo si los perfiles muestran contención.

Mutex frente a canal

Utilice un mutex para proteger un estado compartido con muchos lectores y escritores. Utilice un canal para transferir la propiedad de los datos entre goroutines. Canales para la comunicación; mutexes para la sincronización.

Interfaz sync.Locker

sync.Locker es una interfaz con Lock y Unlock. Tanto Mutex como RWMutex la implementan, lo que permite que las funciones auxiliares acepten cualquiera de los dos tipos.

Comprobación rápida

¿Cuándo debe utilizar sync.RWMutex en lugar de sync.Mutex?

Repaso: Mutex y RWMutex

Puntos clave:

  • Mutex serializa el acceso; utilice siempre defer Unlock
  • Nunca copie un Mutex después de su primer uso
  • RWMutex: varios lectores O un escritor
  • Adquiera los bloqueos siempre en el mismo orden para evitar interbloqueos

Preguntas frecuentes

¿La lección «sync.Mutex y sync.RWMutex» es gratis?

Sí — el texto completo de «sync.Mutex y sync.RWMutex» 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 Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «sync.Mutex y sync.RWMutex»?

Patrones de bloqueo y de bloqueo para lectura y escritura Practicas Go 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 Go Academy?

No se requiere experiencia previa. Go 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 1 de 4.

¿Cuánto tiempo toma la lección «sync.Mutex y sync.RWMutex»?

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 Go Academy?

Sí. Cada lección de Go 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. sync.Mutex y sync.RWMutex
  2. sync.WaitGroup
  3. sync.Once y sync.Map
  4. Detector de condiciones de carrera y patrones seguros
← Volver a Go Academy