協程

多執行緒的概念：從軟體或者硬體上實現多個執行緒併發執行的技術。同一時間執行多於一個執行緒，這時候就會產生資源競爭等

協程的概念：相互之間以同步的方式彼此協作。可以看成是單執行緒的多個函式相互呼叫，但是又有一點點的不同

lua不支援多執行緒，只支援協程的執行方式

如下則是lua協程的類似呼叫過程（假設A是主執行緒，B和C是協程）

A執行三分之一，呼叫B

B執行四分之一，呼叫C

C執行五分之一，掛起（C掛起之後，則呼叫C的B會繼續自行接下去的函式）

B執行到三分之二，掛起（B掛起之後，則A會繼續從三分之一的位置開始執行）

A執行到二分之一，呼叫C（之前C已經執行到了五分之一的位置，則C繼續從五分之一的位置繼續執行下去）

C執行到五分之二，掛起（C掛起之後，則A會繼續從二分之一的位置開始執行）（因為之前是A呼叫的C）

。

。

。

如上所述的呼叫過程可以看出整個過程不會涉及到搶佔和併發的情況，均是同步執行

 1 print("Start A")
 2 
 3 -- 開始可以先建立兩個協程B和C
 4 local C = coroutine.create(function(parentT)
 5     print("Start C from:" .. parentT)
 6     print ("process C to 1/5")
 7     local ret = coroutine.yield("C"
 
)
 8     print ("continue C, from : " .. ret)
 9     print ("end C")
10 
11     -- 返回結果，跟yield(args)是一樣的; 返回給最近一次resume本協程的協程
12     return "end C"
13 end)
14 
15 local B = coroutine.create(function()
16     print("Start B")
17 
18     print ("process B to 1/3")
19     local ret, val = coroutine.resume
 
(C, "B")
20     print ("continue B, get C ret is " .. val)
21     print ("process B to 2/3")
22     local ret = coroutine.yield("B") -- 引數的傳入跟返回均可以多個
23     print ("continue B, from :" .. ret)
24 end)
25 
26 print("process A to 1/3")
27 local ret, val = coroutine.resume(B)
28 print("continue A, get " .. val)
29 print("process A to 1/2")
30 local ret, val = coroutine.resume(C, "A")
31 print("continue A, get ret:" .. val)
32 print("end A")

如上所述的程式碼；執行完之後，顯示如下的結果

Start A
process A to 1/3
Start B
process B to 1/3
Start C from:B
process C to 1/5
continue B, get C ret is C
process B to 2/3
continue A, get B
process A to 1/2
continue C, from : A
end C
continue A, get ret:end C
end A

如上可以看出協程的呼叫方式

如上當coroutine.resume的時候，返回至少一個；ret跟其他的值；其他的值是yield傳進去的引數；ret的值則是此次的resume是否呼叫成功

並且協程裡面的異常不會傳導到外面的呼叫；只會返回ret為false，第二個返回結果為錯誤的原因（可以給它設定個異常即可看出來，如：assert(false) ）

其他：

1、可以檢視每個協程當前的狀態如：coroutine.status(B)

2、判斷當前的協程是否可以掛起：coroutine.isyieldable()

3、還有一個功能跟coroutine.create() 類似的呼叫 coroutine.wrap() 該功能是以裝飾的方式執行

如: A =coroutine.create(.....) 則要將A喚醒需要呼叫coroutine.resume(A)

但是如果使用A =coroutine.wrap(。。。) 則要將A喚醒只需要執行A() ；跟普通的函式呼叫一樣，但是這裡如果執行A的時候發生了異常，則會傳到到外面