Translate

jueves, 19 de noviembre de 2026

Patrón Mailbox: concurrencia sin compartir estado


Uno de los grandes desafíos de la programación concurrente es coordinar varios hilos que necesitan acceder al mismo estado.

La solución tradicional suele involucrar locks, mutexes o synchronized. Pero existe otra alternativa: el patrón Mailbox.

En lugar de permitir que múltiples hilos modifiquen directamente un objeto, hacemos que envíen mensajes a una cola (mailbox). Un consumidor procesa esos mensajes de manera secuencial y actualiza el estado.

Por ejemplo, imaginemos una cuenta bancaria:


sealed trait Mensaje

case class Depositar(monto: Int) extends Mensaje

case class Retirar(monto: Int) extends Mensaje


var saldo = 0


def procesar(mensaje: Mensaje): Unit =

  mensaje match

    case Depositar(monto) =>

      saldo += monto


    case Retirar(monto) =>

      if saldo >= monto then

        saldo -= monto


En una implementación basada en Mailbox, los mensajes se encolarían y un único consumidor ejecutaría procesar de forma secuencial.

Si llegan Depositar(100) y Retirar(30), el consumidor procesa ambas operaciones sin que dos hilos modifiquen simultáneamente el saldo.


¿Qué ventajas ofrece?

  • Reduce las condiciones de carrera sobre el estado del consumidor.
  • Desacopla a quienes envían mensajes de quienes los procesan.
  • Facilita la comunicación asíncrona.
  • Permite escalar mediante múltiples consumidores o actores independientes, cada uno con su propio estado.


¿Dónde encontramos este patrón?

En sistemas basados en actores, como Akka en Scala, y en entornos como Erlang y Elixir.

La idea fundamental: en lugar de compartir estado entre hilos, compartimos mensajes.


Porque muchas veces, la mejor forma de gestionar la concurrencia no es agregar más locks, sino cambiar la forma en que los componentes se comunican.

No hay comentarios.:

Publicar un comentario