Multitarea en Lua

Voy a compartir con vosotros, una nueva característica de Lua que he estado estudiando, a
pesar de ser un lenguaje interpretado permite multitarea. No es una multitarea "real", o
preferente tal como la de POSIX que podemos encontrar en los lenguajes compilados, es
una tarea "cooperativa". Esto quiere decir, que es el programador el que tiene que crear
los puntos de interrupción en su código para dar paso a otras tareas, en vez de gestionar
dichas interrupciones el Sistema Operativo o el lenguaje (como por ejemplo hace POSIX).

Ventajas de la multitarea cooperativa de Lua:

     Funciona en Lua nativo. Es decir, no necesitas usar ninguna aplicación externa en
un lenguaje compilado.
     Será compatible en cualquier intérprete Lua que uses.
     No hace falta programar nada en otros lenguajes.

Desventajas:
     No es una "multitarea real", en sentido amplio de la palabra.
     El Programador tiene que gestionar los puntos de interrupción, lo que requiere
una buena planificación del código y tener muy claro el tiempo que va tardar en
completarse una rutina o algoritmo determinado.
     Se puede colapsar toda la aplicación si un proceso no termina

Mejor voy a explicar todo esto con un ejemplo, veréis que no es muy complicado. En
primer lugar vamos a hacer un código normal, tiene 3 funciones con un código básico a las
que hemos llamado proceso1, 2 y 3.

function proceso1()
local n
print("Proceso1: Imprime los números de 1 al 4 y luego del 4 al 1")
for n = 1, 4 do
print("proceso1: ", n)
end
--coroutine.yield()
for n = 4, 1, -1 do
print("proceso1: ", n)
end
 
end
 
function proceso2()
local j, n
print("Proceso2: Imprime 2 veces los números de 1 al 3")
for j = 1, 2 do
for n = 1, 3 do
print("proceso2 (ronda "..j.."): ",n)
end
 --coroutine.yield()
end
end
 
function proceso3(num)
local n, total
print("Proceso3: Recibe un número y le suma 5 en 3 veces, lo devuelve
en cada suma")
total = num
for n = 1, 3 do
total = total + 5
print("proceso3 (ronda "..n..") recibido "..num.." y acumulado:",
total)
end
end
 
proceso1()
proceso2()
proceso3(50)

La forma de ejecutar este código, lógicamente es llamando a una función o proceso cada
vez. Si lo ejecutamos veríamos por la consola lo siguiente:

Proceso1: Imprime los números de 1 al 4 y luego del 4 al 1

proceso1: 1
proceso1: 2
proceso1: 3
proceso1: 4
proceso1: 4
proceso1: 3
proceso1: 2
proceso1: 1
Proceso2: Imprime 2 veces los números de 1 al 3
proceso2 (ronda 1): 1
proceso2 (ronda 1): 2
proceso2 (ronda 1): 3
proceso2 (ronda 2): 1
proceso2 (ronda 2): 2
proceso2 (ronda 2): 3
Proceso3: Recibe un número y le suma 5 en 3 veces, lo devuelve en cada
suma
proceso3 (ronda 1) recibido 50 y acumulado: 55
proceso3 (ronda 2) recibido 50 y acumulado: 60
proceso3 (ronda 3) recibido 50 y acumulado: 65

Fijaos bien en el código anterior, hasta que lo comprendáis, ES MUY IMPORTANTE

para entender lo que viene después. Para facilitar las indicaciones, he numerado las
lineas del siguiente listado.

1 function proceso1()
2 local n
3 print("Proceso1: Imprime los números de 1 al 4 y luego del 4
al 1")
4 for n = 1, 4 do
5 print("proceso1: ", n)
 6 end
7 coroutine.yield()
8 for n = 4, 1, -1 do
9 print("proceso1: ", n)
10 end
11 end
12
13 function proceso2()
14 local j, n
15 print("Proceso2: Imprime 2 veces los números de 1 al 3")
16 for j = 1, 2 do
17 for n = 1, 3 do
18 print("proceso2 (ronda "..j.."): ",n)
19 end
20 coroutine.yield()
21 end
22 end
23
24 function proceso3(num)
25 local n, total
26 print("Proceso3: Recibe un número y le suma 5 en 3 veces, lo
devuelve en cada suma")
27 total = num
28 for n = 1, 3 do
29 total = total + 5
30 print("proceso3 (ronda "..n..") recibido "..num.." y
acumulado:", total)
31 coroutine.yield(total)
32 end
33 end
34
35 --Creamos las corutinas o "procesos"
36 coPro1 = coroutine.create(proceso1)
37 coPro2 = coroutine.create(proceso2)
38 coPro3 = coroutine.create(proceso3)
39 local valorPro3, foo
40 while true do
41 --Comprobamos que todas las corutinas hayan terminado
42 --status() devuelve "dead" cuando el proceso o función haya
terminado
43 if coroutine.status(coPro1) == "dead" and
44 coroutine.status(coPro2) == "dead" and
45 coroutine.status(coPro3) == "dead" then
46 break
47 end
48 --Vamos ejecutando "las partes" de los procesos
49 coroutine.resume(coPro1)
50 coroutine.resume(coPro2)
51 foo, valorPro3 = coroutine.resume(coPro3, 50)
52 print("El valor del proceso3, ahora vale: ", valorPro3)
53 end

Lo primero que vemos es que en los procesos (en realidad son funciones, pero quiero
llamarlo procesos para que comprendáis mejor el concepto de multitarea), en las lineas 7,20
y 31, hemos incluido una instrucción coroutine.yield() (ceder). Esto representa el punto
donde queremos que nuestro proceso termine temporalmente y pase el control al proceso
principal. En este ejemplo hay un yield() por proceso, pero se pueden poner los que
quieran, eso sí, como veréis más adelante, es conveniente planificar bien dónde se colocan.

En las lineas 36, 37 y 38. Creamos las "corutinas", coPro1, 2, y 3. Contienen un puntero de
un proceso. El parámetro es la función llamada. Por ejemplo en la linea 36, estamos
diciendo que coPro1, es un proceso que apunta a la función proceso1.

En la linea 39, definimos 2 variables locales, que más adelante os diré para qué son.
NOTA: Acostrumbraros a definir las variables como locales si no os pueden dar conflicto
con otras en otros módulos con el mismo nombre, error MUY difícil de detectar.

En 40, creamos un bucle, este bucle funcionará hasta que todos los procesos terminen. La
forma de hacer esto es comprobar el estado (status) de cada proceso como se hace en la
linea 43. status devuelve "dead" si el proceso ha terminado (esta muerto vamos xDD).

Bien, ahora en 49, 50 y 51, viene quizás lo más importante, hacemos un resume (resumen)
de los procesos. La primera vez que llamamos a resume(), se ejecuta el proceso hasta que
encuentra una instrucción yield(), momento en el que regresa. Al volver a llamar a
resume(), continúa donde lo dejó, y sigue hasta el yield(), así hasta que acaba el proceso.

En 51, he incluido estas variables para que veáis que se pueden enviar variables, y recibir
resultados de los procesos. Fijaos que hemos puesto un segundo parámetro en resume, el
valor 50, que es el parámetro que le enviamos al proceso3 inicialmente. Lua, puede
devolver más de un valor, al contrario de lo que suele ser "normal" en otros lenguaje que
devuelven uno o ninguno. yield() SIEMPRE devuelve true, y los parámetros que se le
digan separados por comas, en este caso en la linea 31 yield(), sólo devuelve uno más, el
total. Por cierto, no me preguntéis porque siempre devuelve true como primer parámetro y
no le busquéis sentido porque no lo tiene, xDDDDD. El hecho de usar "foo", es poner una
variable para que reciba el valor true que no nos interesa procesar.

Esta es la salida que produce el código usando corutinas:

Proceso1: Imprime los números de 1 al 4 y luego del 4

proceso1: 1
proceso1: 2
proceso1: 3
proceso1: 4
Proceso2: Imprime 2 veces los números de 1 al 3
proceso2 (ronda 1): 1
proceso2 (ronda 1): 2
proceso2 (ronda 1): 3
Proceso3: Recibe un número y le suma 5 en 3 veces, lo
proceso3 (ronda 1) recibido 50 y acumulado: 55
El valor del proceso3, ahora vale: 55
proceso1: 4
proceso1: 3
proceso1: 2
proceso1: 1
proceso2 (ronda 2): 1
proceso2 (ronda 2): 2
proceso2 (ronda 2): 3
proceso3 (ronda 2) recibido 50 y acumulado: 60
El valor del proceso3, ahora vale: 60
proceso3 (ronda 3) recibido 50 y acumulado: 65
El valor del proceso3, ahora vale: 65

Se puede ver cómo se han ido alternando los diferente procesos, lo cual da una sensación de
"multitarea".

Terminado:
Aunque esto sea una "multitarea cooperativa", en vez de una real o preferente, hace un
apaño y más teniendo en cuenta de que se trata de un lenguaje interpretado. Espero que os
haya servido de algo.

Los comentarios son de agradecer y motivan a crear más tutoriales ;-).

Un saludo.