(Notas de Lua): Corrotina Lua

 

Lua corrotina

Primeiros passos caso 1

• Crie e inicie a co-rotina
  • Defina a função de co-rotina coroutine.create ()
  • Inicie o coroutine.resume ()

co=coroutine.create(   --创建协程函数
	function (a,b)
		print(a+b)
	end
)

coroutine.resume(co,20,30)  --启动协程函数

Caso 2 de introdução

• Crie uma co-rotina através de coroutine.wrap () e inicie-a

co=coroutine.wrap(
	function (a,b)
		print(a+b)
	end
)

co(20,30)

Primeiros passos, caso 3

• Use coroutine.yield () para suspender a co-rotina no meio do caminho e comece novamente, a segunda vez que coroutine.resume () não precisa passar parâmetros

co=coroutine.create(
	function (a,b)
		print(a+b)
		coroutine.yield()
		print(a-b)
	end
)
coroutine.resume(co,1,2)
print("I'm here!")
coroutine.resume(co)

输出：
3
I'm here!
-1

Primeiros passos, caso 4

• coroutine.status ()
• Existem três estados de co-rotina: morto, suspenso, em execução

co=coroutine.create(
	function (a,b)
		print(a+b)
		print(coroutine.status(co))   --running
		print(a+b)
		coroutine.yield()
		print(a-b)
	end
)
print(coroutine.status(co))  --此时未启动协程，suspended

coroutine.resume(co,10,20) 

print(coroutine.status(co))  --suspended

print("I'm here!")  

coroutine.resume(co) 

print(coroutine.status(co))   --dead

Caso inicial 5

• coroutine.running ()
• Retorne a co-rotina em execução. Uma co-rotina é uma rosca. Quando a execução é usada, ela retorna um número de rosca corretiva.

co=coroutine.create(
	function (a,b)
		print( coroutine.running() )  --thread: 00A78110
		coroutine.yield()
		print(a-b)
	end
)
print( coroutine.running() )  --nil

coroutine.resume(co,10,40)

print("I'm here!")

coroutine.resume(co)

Introdução 6

• A co-rotina pode retornar vários valores. O primeiro valor é um valor booleano, que indica se a co-rotina foi iniciada com sucesso e o valor de retorno da função de co-rotina é o seguinte

co=coroutine.create(
	function (a,b)

		coroutine.yield(a*b,a/b)

		return a%b,a/b+1
	end
)
res1,res2,res3 = coroutine.resume(co,10,40)
print(res1,res2,res3)  --true	400	0.25

print("I'm here!")

res1,res2,res3 = coroutine.resume(co)
print(res1,res2,res3)  --true	10	1.25

Resumindo

método	descrição
coroutine.create ()	Criar co-rotina, retornar co-rotina, o parâmetro é uma função, quando usado em conjunto com resume, a chamada de função é ativada
coroutine.resume ()	Reinicie a co-rotina e use-a com criar
coroutine.yield ()	Suspender a co-rotina, definir a co-rotina para o estado suspenso, isso pode ter muitos efeitos úteis em conjunto com a retomada
coroutine.status ()	Ver o status da co-rotina Nota: Existem três status da co-rotina: morta, suspensa e em execução. Por favor, consulte o seguinte programa para saber quando existe tal status
coroutine.wrap （）	Crie uma co-rotina e retorne uma função. Depois de chamar esta função, entre na co-rotina e repita a função de criação
coroutine.running ()	Retorne a co-rotina em execução. Uma co-rotina é uma rosca. Quando a execução é usada, ela retorna um número de rosca corretiva.

• A co-rotina é implementada como uma rosca na parte inferior.
• Quando uma co-rotina é criada, um evento é registrado no novo thread.
• Quando o evento de ativação de retomada é usado, a função de co-rotina de criar é executada.Quando o rendimento é encontrado, o segmento atual é suspenso, aguardando pelo evento de ativação de retomada novamente.

Caso abrangente

function foo (a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回  2*a 的值
end
 
co = coroutine.create(function (a , b)
    print("第一次协同程序执行输出", a, b) -- co-body 1 10
    local r = foo(a + 1)
     
    print("第二次协同程序执行输出", r)
    local r, s = coroutine.yield(a + b, a - b)  -- a，b的值为第一次调用协同程序时传入
     
    print("第三次协同程序执行输出", r, s)
    return b, "结束协同程序"                   -- b的值为第二次调用协同程序时传入
end)
        
print("main", coroutine.resume(co, 1, 10)) -- true, 4

print("main", coroutine.resume(co, "r")) -- true 11 -9

print("main", coroutine.resume(co, "x", "y")) -- true 10 end

print("main", coroutine.resume(co, "x", "y")) -- false cannot resume dead coroutine

• O exemplo acima continua da seguinte maneira:
  • Chame resume para despertar o programa cooperativo. A operação resume retorna true se for bem-sucedida, caso contrário, retorna false;
  • Operação de programa cooperativo;
  • Corra para a declaração de rendimento;
  • O rendimento suspende o programa colaborativo e o primeiro currículo retorna; (nota: aqui o rendimento retorna, e o parâmetro é o parâmetro do currículo)
  • Na segunda vez de retomada, desperte novamente o programa cooperativo; (nota: nos parâmetros de retomada, exceto para o primeiro parâmetro, os demais parâmetros serão usados ​​como parâmetros de rendimento) retorno de rendimento;
  • O programa cooperativo continua funcionando;
  • Se o co-programa usado continuar a executar e continuar a chamar o método de retomada após a conclusão, a saída: não é possível retomar a co-rotina morta
  • A combinação poderosa de currículo e rendimento é que o currículo está no processo principal e transfere o estado externo (dados) para a parte interna do programa colaborativo; enquanto o rendimento retorna o estado interno (dados) para o processo principal.

• Problema produtor-consumidor

local newProductor

function productor()
     local i = 0
     while true do
          i = i + 1
          send(i)     -- 将生产的物品发送给消费者
     end
end

function consumer()
     while true do
          local i = receive()     -- 从生产者那里得到物品
          print(i)
     end
end

function receive()
     local status, value = coroutine.resume(newProductor)
     return value
end

function send(x)
     coroutine.yield(x)     -- x表示需要发送的值，值返回以后，就挂起该协同程序
end

-- 启动程序
newProductor = coroutine.create(productor)
consumer()

输出：
1    2    3    4    5    6    7    8    9    10    11    12    13    ...

• [Nota]: Consulte https://www.runoob.com/lua