關于Lua協同程序的內容是本文要介紹的內容，主要是來學習lua中線程的使用方法，關于系統程序，本文有詳解，具體內容一起來看詳解。

1、什么是協同(coroutine)？

協同程序(coroutine)與線程比較類似：擁有獨立的堆棧，獨立的局部變量，獨立的指令指針，但是和其他協同程序共享全局變量等很多信息。
  
線程和協同程序的主要不同在于：在多處理器情況下，從概念上來講多線程程序同時運行多個線程；而協同程序是通過協作來完成，在任一指定時刻只有一個協同程序在運行，并且這個正在運行的協同程序只有在明確的被要求掛起的時候才會被掛起。協作程序有點類似同步的多線程，在等待同一個線程鎖的幾個線程有點類似協同。

協同和順序執行的區別？任一制定時刻只能運行一個協同程序，這個和順序執行區別在哪？關鍵在于yield函數。如果順序執行的時候進行耗費cpu時間或者一直等待某個資源的時候，程序將卡在這個地方不能前進。協同程序的出現就是可以使等待資源的線程讓出資源，進行下一個協同程序的操作。yield可以在執行出錯的時候掛起，下次恢復的時候再進行操作。

2、協同(coroutine)的幾個狀態

掛起態：創建一個協同程序時他開始的狀態為掛起態，函數coroutine.yield可以使程序由運行態變為掛起狀態

運行態：函數coroutine.resume可以使程序由掛起狀態變為運行態

停止態：協同程序結束，進入停止態

3、coroutine.resume

resume可以給協同程序傳參數，并將掛起態程序恢復為運行態

coroutinecoroutine.co = coroutine.create(function (a,b,c)  
    print("co", a, b, c)  
end)  
coroutine.resume(co, 1, 2, 3) --> co 1 2 3resume 

coroutine.resume直到線程結束或者遇到coroutine.yield時返回。

（1）coroutine.resume的參數：線程函數***次運行，參數作為線程函數參數；如果yield沒有顯式返回參數，則coroutine.resume的參數作為yield的額外參數返回。

（2）如果是掛起狀態(一開始也是掛起狀態)，繼續運行resume函數返回true；如果線程已經停止或者遇到其他錯誤，resume函數返回false及錯誤信息。

（3）線程結束則線程主函數的返回值作為coroutine.resume的附加返回值。

這點特性很微妙，可以看出coroutine.resume其實是個阻塞函數，阻塞等待協同程序完成或者yield退出。可以把協同程序當成一個等待對象，對象等待返回則coroutine.resume返回。在coroutine.resume調用的地方阻塞調用線程，這個特性要記住！

4、coroutine.yield

yield可以返回額外參數，或者掛起協同程序

co = coroutine.create(function (a,b)  
    coroutine.yield(a + b, a - b)  
end)  
print(coroutine.resume(co, 20, 10)) --> true 30 10  
 
co = coroutine.create (function ()  
    print("co", coroutine.yield())  
end)  
coroutine.resume(co)  
coroutine.resume(co, 4, 5) --> co 4 5 

使用函數yield可以使程序掛起并返回狀態給resume,當我們激活被掛起的程序時，yield返回(這里的返回是說從阻塞狀態返回)并繼續程序的執行直到再次遇到yield或者程序結束

5、對稱協同和不對稱協同

對稱協同：執行到掛起之間狀態轉換的函數是相同的

不對稱協同：掛起一個正在執行的協同的函數與使一個被掛起的協同再次執行的函數是不同的(resum和yield)
 
6、消費者驅動的生產者-消費者模型

當消費者需要值時他喚起生產者生產值，生產者生產值后停止直到消費者再次請求。我們稱這種設計為消費者驅動的設計。平常多見的生產者-消費者模型，是產品驅動的設計，生產者不斷生產產品，消費者用臨界區保護取產品消費

協同為解決這種問題提供了理想的方法，因為調用者與被調用者之間的resume-yield關系會不斷顛倒。當一個協同調用yield時并不會進入一個新的函數，取而代之的是返回一個未決的resume的調用。相似的，調用resume時也不會開始一個新的函數而是返回yield的調用。這種性質正是我們所需要的，與使得send-receive協同工作的方式是一致的：receive喚醒生產者生產新值，send把產生的值送給消費者消費。

function receive (prod)  
    local status, value = coroutine.resume(prod)  
    return value  
end  
 
function send (x)  
    coroutine.yield(x)  
end  
 
function producer ()  
    return coroutine.create(function ()  
        while true do  
            local x = io.read() -- produce new value  
            send(x)  
        end  
 
    end)  
end  
 
function filter (prod)  
    return coroutine.create(function ()  
        local line = 1 
        while true do  
            local x = receive(prod) -- get new value  
            x = string.format("%5d %s", line, x)  
            send(x) -- send it to consumer  
            lineline = line + 1  
        end  
    end)  
end  
 
coroutine.resumefunction consumer (filter)  
    while true do  
        local x = receive(filter) -- get new value  
        io.write(x, "\n") -- consume new value  
    end  
end  
p = producer()  
f = filter(p)  
consumer(f) 

看完上面這個例子你可能很自然的想到UNIX的管道，協同是一種非搶占式的多線程。管道的方式下，每一個任務在獨立的進程中運行，而協同方式下，每個任務運行在獨立的協同代碼中。管道在讀（consumer）與寫（producer）之間提供了一個緩沖，因此兩者相關的的速度沒有什么限制，在上下文管道中這是非常重要的，因為在進程間的切換代價是很高的。協同模式下，任務間的切換代價較小，與函數調用相當，因此讀寫可以很好的協同處理。

小結：解析關于Lua協同程序的內容介紹完了，希望通過本文的學習能對你有所幫助！