并發是現實世界的本質特征，而聰明的計算機科學家用來模擬并發的技術手段便是多任務機制。大致上有這么兩種多任務技術，一種是搶占式多任務 (preemptive multitasking)，它讓操作系統來決定何時執行哪個任務。另外一種就是協作式多任務(cooperative multitasking)，它把決定權交給任務，讓它們在自己認為合適的時候自愿放棄執行。這兩種多任務方式各有優缺點，前者固有的同步問題使得程序經 常有不可預知的行為，而后者則要求任務具備相當的自律精神。
　　　　協程(coroutine)技術是一種程序控制機制，早在上世紀60年代就已 提出，用它可以很方便地實現協作式多任務。在主流的程序語言(如C++、Java、Pascal等)里我們很少能看到協程的身影，但是現在不少動態腳本語 言(Python、Perl)卻都提供了協程或與之相似的機制，其中最突出的便是Lua。
　　
　　　　Lua語言實現的協程是一種非對稱 式(asymmetric)協程，或稱半對稱式(semi-asymmetric)協程，又或干脆就叫半協程(semi-coroutine)。這種協程 機制之所以被稱為非對稱的，是因為它提供了兩種傳遞程序控制權的操作：一種是(重)調用協程(通過coroutine.resume)；另一種是掛起協程 并將程序控制權返回給協程的調用者(通過coroutine.yield)。一個非對稱協程可以看做是從屬于它的調用者的，二者的關系非常類似于例程 (routine)與其調用者之間的關系。既然有非對稱式協程，當然也就有對稱式(symmetric)協程了，它的特點是只有一種傳遞程序控制權的操 作，即將控制權直接傳遞給指定的協程。曾經有這么一種說法，對稱式和非對稱式協程機制的能力并不等價，但事實上很容易根據前者來實現后者。接下來我們就用 代碼來證明這個事實。
　　
　　--對稱式協程庫coro.lua
　　
　　coro = {}
　　--coro.main用來標識程序的主函數
　　coro.main = function() end
　　-- coro.current變量用來標識擁有控制權的協程，
　　-- 也即正在運行的當前協程
　　coro.current = coro.main
　　
　　-- 創建一個新的協程
　　function coro.create(f)
　　　 return coroutine.wrap(function(val)
　　　　　　　　　　　　　　　　return nil,f(val)
　　　　　　　　　　　　　　 end)
　　end
　　
　　-- 把控制權及指定的數據val傳給協程k
　　function coro.transfer(k,val)
　　　 if coro.current ~= coro.main then
　　　　　return coroutine.yield(k,val)
　　　 else
　　　　　-- 控制權分派循環
　　　　　while k do
　　　　　　 coro.current = k
　　　　　　 if k == coro.main then
　　　　　　　　return val
　　　　　　 end
　　　　　　 k,val = k(val)
　　　　　end
　　　　　error("coroutine ended without transfering control...")
　　　 end
　　end
　　
　　如果暫時還弄不懂上面的程序，沒關系，看看如何使用這個庫后再回頭分析。下面是使用示例：
　　
　　require("coro.lua")
　　
　　function foo1(n)
　　　 print("1: foo1 received value "..n)
　　　 n = coro.transfer(foo2,n + 10)
　　　 print("2: foo1 received value "..n)
　　　 n = coro.transfer(coro.main,n + 10)
　　　 print("3: foo1 received value "..n)
　　　 coro.transfer(coro.main,n + 10)
　　end
　　
　　function foo2(n)
　　　 print("1: foo2 received value "..n)
　　　 n = coro.transfer(coro.main,n + 10)
　　　 print("2: foo2 received value "..n)
　　　 coro.transfer(foo1,n + 10)
　　end
　　
　　function main()
　　　 foo1 = coro.create(foo1)
　　　 foo2 = coro.create(foo2)
　　　 local n = coro.transfer(foo1,0)
　　　 print("1: main received value "..n)
　　　 n = coro.transfer(foo2,n + 10)
　　　 print("2: main received value "..n)
　　　 n = coro.transfer(foo1,n + 10)
　　　 print("3: main received value "..n)
　　end
　　
　　--把main設為主函數(協程)
　　coro.main = main
　　--將coro.main設為當前協程
　　coro.current = coro.main
　　--開始執行主函數(協程)
　　coro.main()
　　
　　
　 　上面的示例定義了一個名為main的主函數，整個程序由它而始，也因它而終。為什么需要一個這樣的主函數呢？上面說了，程序控制權可以在對稱式協程之間 自由地直接傳遞，它們之間無所謂誰從屬于誰的問題，都處于同一個層級，但是應用程序必須有一個開始點，所以我們定義一個主函數，讓它點燃程序運行的導火 線。雖說各個協程都是平等的，但做為程序運行原動力的主函數仍然享有特殊的地位(這個世上哪有絕對的平等！)，為此我們的庫專門用了一個 coro.main變量來保存主函數，并且在它執行之前要將它設為當前協程(雖然上面的main實際只是一個普通函數而非一個真正的協程，但這并無太大的 關系，以后主函數也被稱為主協程)。示例運行的結果是：
　　
　　1: foo1 received value 0
　　1: foo2 received value 10
　　1: main received value 20
　　2: foo2 received value 30
　　2: foo1 received value 40
　　2: main received value 50
　　3: foo1 received value 60
　　3: main received value 70
　　
　　協程的執行序列是：main->foo1->foo2->main->foo2->foo1->main->foo1->main。
　　
　 　　　coro.transfer(k,val)函數中k是將要接收程序控制權的協程，而val是傳遞給k的數據。如果當前協程不是主協程， tansfer(k,val)就簡單地利用coroutine.yield(k,val)將當前協程掛起并傳回兩項數據，即程序控制權的下一站和傳遞給它 的數據；否則進入一個控制權分派(dispatch)循環，該循環(重)啟動(resume)k協程，等待它執行到掛起(suspend)，并根據此時協 程傳回的數據來決定下一個要(重)啟動的協程。從應用示例來看，協程與協程之間似乎是用transfer直接傳遞控制權的，但實際上這個傳遞還是通過了主 協程。每一個在主協程里被調用(比較coro.current和coro.main是否相同即可判斷出)的transfer都相當于一個協程管理器，它不 斷地(重)啟動一個協程，將控制權交出去，然后等那個協程掛起時又將控制權收回，然后再(重)啟動下一個協程...，這個動作不會停止，除非< 1>將(重)啟動的協程是主協程；<2>某個協程沒有提供控制權的下一個目的地。很顯然，每一輪分派循環開始時都由主協程把握控制權， 在循環過程中如果控制權的下一站又是主協程的話就意味著這個當初把控制權交出去的主協程transfer操作應該結束了，所以函數直接返回val從而結束 這輪循環。對于情況<2>，因為coro.create(f)創建的協程的體函數(body function)實際是function(val) return nil,f(val) end，所以當函數f的最后一條指令不是transfer時，這個協程終將執行完畢并把nil和函數f的返回值一起返回。如果k是這樣的協程， transfer執行完k,val = k(val)語句后k值就成了nil，這被視為一個錯誤，因為程序此時沒法確定下一個應該(重)啟動的協程到底是誰。所以在對稱式模型下，每一個協程(當 然主協程出外)最后都必須顯式地將控制權傳遞給其它的協程。根據以上分析，應用示例的控制權的分派應為：
　　
　　第一輪分派: main->foo1->main->foo2->main->main(結束)
　　第二輪分派: main->foo2->main->foo1->main->main(結束)
　　第三輪分派: main->foo1->main->main(結束)
　　
　 　　　由于可以直接指定控制權傳遞的目標，對稱式協程機制擁有極大的自由，但得到這種自由的代價卻是犧牲程序結構。如果程序稍微復雜一點，那么即使是非常 有經驗的程序員也很難對程序流程有全面而清晰的把握。這非常類似goto語句，它能讓程序跳轉到任何想去的地方，但人們卻很難理解充斥著goto的程序。 非對稱式協程具有良好的層次化結構關系，(重)啟動這些協程與調用一個函數非常類似：被(重)啟動的協程得到控制權開始執行，然后掛起(或結束)并將控制 權返回給協程調用者，這與計算機先哲們倡導的結構化編程風格完全一致。
　　
　　　　綜上所述，Lua提供的非對稱式協程不但具有與對稱式協程一樣強大的能力，而且還能避免程序員濫用機制寫出結構混亂的程序。