El ciclo: create, resume, yield y los cuatro estados

El ciclo de vida de una corrutina cabe en tres funciones y cuatro estados, y sin embargo concentra la mayoría de los errores de quien empieza. La causa es casi siempre la misma: suponer que create ejecuta algo, que resume devuelve lo mismo que la función, o que una corrutina terminada se puede volver a usar. Ninguna de las tres cosas es cierta. Esta lección recorre el ciclo completo desde la creación hasta la muerte, fija el instante exacto en que ocurre cada transición y aclara qué contesta coroutine.status en cada momento, incluido el estado que casi nadie sabe explicar.

Crear no es ejecutar

coroutine.create recibe una función de Lua y devuelve un valor de tipo thread. Y eso es todo lo que hace: reserva una pila nueva, anota cuál es la función que habrá que arrancar y devuelve el objeto suspendido. Ni una sola instrucción del cuerpo se ha ejecutado todavía.

local co = coroutine.create(function(...)
  print("esta linea no se ha impreso aun")
  return "listo"
end)

print(type(co), coroutine.status(co))   --> thread   suspended

La consecuencia práctica importa más de lo que parece. Puedes crear cien mil corrutinas en el arranque de tu programa y no pagas ningún coste de ejecución por ellas, solo el de la memoria de sus pilas vacías. Puedes crearlas y no reanudarlas nunca. Y puedes crear una corrutina cuya función lance un error inmediatamente sin que el error aparezca hasta el primer resume, lo que en la práctica significa que la creación nunca falla por culpa del cuerpo.

La primera llamada a resume es la que arranca de verdad: llama a la función con los argumentos que le pasaste después de la corrutina y ejecuta el cuerpo sobre la pila propia hasta que ocurra una de tres cosas. O la función cede con yield, o retorna, o lanza un error. No hay una cuarta posibilidad, y esas tres salidas gobiernan todo el resto de la lección.

Los cuatro estados

coroutine.status devuelve una de cuatro cadenas, y solo tres son fáciles.

Suspendida. Es el estado inicial y el que resulta de cada cesión. La corrutina existe, tiene estado guardado y está esperando un resume. Es el único estado desde el que se puede reanudar.

Corriendo. Es la corrutina que está ejecutando en este preciso instante. Solo puede haber una en todo el estado de Lua, lo que es otra forma de decir que no hay paralelismo. Preguntar el estado de una corrutina y obtener este valor significa necesariamente que se lo estás preguntando a sí misma.

Muerta. Su función terminó, por retorno o por error, y no admite más reanudaciones. La muerte es definitiva: no existe ninguna operación que reviva una corrutina, y si necesitas repetir el trabajo tienes que crear otra.

Normal. Este es el que casi nadie sabe explicar. Una corrutina está en estado normal cuando ha reanudado a otra y está esperando a que aquella le devuelva el control. No está corriendo, porque quien corre es la que ella reanudó; y no está suspendida, porque no cedió, sino que está en mitad de una llamada a resume. Es, literalmente, el estado de un eslabón intermedio de la cadena, y su existencia es la prueba visible de que el modelo asimétrico apila las corrutinas activas.

stateDiagram-v2
[*] --> suspended: create
suspended --> running: resume
running --> suspended: yield
running --> dead: return
running --> dead: error
running --> normal: reanuda a otra corrutina
normal --> running: la otra cede o termina
dead --> [*]

local interna = coroutine.create(function(padre)
  print("interna ve al padre como", coroutine.status(padre))   --> normal
  coroutine.yield()
end)

local externa = coroutine.create(function()
  local yo = coroutine.running()
  print("externa se ve a si misma como", coroutine.status(yo))  --> running
  coroutine.resume(interna, yo)
end)

coroutine.resume(externa)
print(coroutine.status(externa), coroutine.status(interna))     --> dead   suspended

Morir, y qué devuelve el resume que la mata

Una corrutina muere en el instante en que su función principal termina, y ese instante tiene una firma reconocible en el valor de retorno de resume. Recuerda la forma general: resume devuelve un booleano de éxito seguido de valores.

Cuando la corrutina cede, los valores que siguen al booleano son los argumentos de yield. Cuando la corrutina retorna, los valores que siguen al booleano son los que devolvió la función, y la corrutina queda muerta. Desde fuera, las dos situaciones se distinguen consultando el estado después, no por la forma del retorno: true seguido de un valor puede significar tanto cedió esto como terminó devolviendo esto.

local co = coroutine.create(function()
  coroutine.yield("a")
  return "b"
end)

print(coroutine.resume(co), coroutine.status(co))   --> true a  suspended
print(coroutine.resume(co), coroutine.status(co))   --> true b  dead
print(coroutine.resume(co))                         --> false  cannot resume dead coroutine

Esa ambigüedad no es un descuido del diseño, es una consecuencia de que Lua no quiere imponerte un protocolo. Si tu código necesita distinguir el último valor de los intermedios, la solución idiomática no es consultar el estado sino acordar un centinela: que el productor ceda valores mientras los tenga y retorne un valor especial —o simplemente nada— cuando se acabe. El consumidor sabrá que terminó porque recibió el centinela, no porque preguntó.

El otro camino hacia la muerte es el error, que la lección 15.4 trata a fondo. Baste aquí con la parte del ciclo de vida: un error no propagado dentro de la corrutina la mata igual que un retorno, y el resume correspondiente devuelve false y el objeto de error en vez de true y los valores.

Consultar el estado, y por qué casi nunca deberías

Hay tres funciones de consulta. coroutine.status acepta un hilo y devuelve una de las cuatro cadenas. coroutine.running devuelve el hilo que está ejecutando y un booleano que indica si es el principal. coroutine.isyieldable responde si una cesión sería legal en el punto actual, que es lo mismo que preguntar si estamos dentro de una corrutina reanudable.

local function soy_reanudable()
  local yo, es_principal = coroutine.running()
  return coroutine.isyieldable(), es_principal, coroutine.status(yo)
end

Ahora la advertencia de diseño, que es el contenido real de esta sección. Escribir código que consulta el estado de otra corrutina para decidir qué hacer es, en la inmensa mayoría de los casos, un síntoma de que el protocolo entre las dos partes no está definido. Preguntar sigue viva antes de reanudar es redundante, porque resume ya te contesta eso con su primer valor de retorno y además lo hace sin ventana de tiempo entre la pregunta y la acción. Preguntar está suspendida para decidir si reanudar es equivalente. Y consultar el estado de una corrutina que no eres tú y a la que no acabas de reanudar es sencillamente imposible que sea útil, porque si no la reanudaste tú, su estado no depende de ti.

El uso legítimo de estas funciones es la introspección: depuración, trazas, paneles de diagnóstico y bibliotecas que gestionan colecciones de corrutinas ajenas. coroutine.isyieldable sí tiene además un uso corriente y honesto, que es escribir funciones capaces de comportarse de dos maneras según se las llame desde dentro o fuera de una corrutina, típico en bibliotecas de entrada y salida que ceden si pueden y bloquean si no.