(zt)Lua的多任務機制——協程(coroutine)

標籤：style   blog   http   java   color   使用   

原帖：http://blog.csdn.net/soloist/article/details/329381

   並發是現實世界的本質特徵，而聰明的電腦科學家用來類比並發的技術手段便是多任務機制。大致上有這麼兩種多任務技術，一種是搶佔式多任務(preemptive multitasking)，它讓作業系統來決定何時執行哪個任務。另外一種就是協作式多任務(cooperative multitasking)，它把決定權交給任務，讓它們在自己認為合適的時候自願放棄執行。這兩種多任務方式各有優缺點，前者固有的同步問題使得程式經常有不可預知的行為，而後者則要求任務具備相當的自律精神。

    協程(coroutine)技術是一種程式控制機制，早在上世紀60年代就已提出，用它可以很方便地實現協作式多任務。在主流的程式語言(如C++、Java、Pascal等)裡我們很少能看到協程的身影，但是現在不少動態指令碼語言(Python、Perl)卻都提供了協程或與之相似的機制，其中最突出的便是Lua。

    Lua語言實現的協程是一種非對稱式(asymmetric)協程，或稱半對稱式(semi-symmetric)協程，又或乾脆就叫半協程(semi-coroutine)。這種協程機制之所以被稱為非對稱的，是因為它提供了兩種傳遞程式控制權的操作：一種是(重)調用協程(通過coroutine.resume)；另一種是掛起協程並將程式控制權返回給協程的調用者(通過coroutine.yield)。一個非對稱協程可以看做是從屬於它的調用者的，二者的關係非常類似於常式(routine)與其調用者之間的關係。既然有非對稱式協程，當然也就有對稱式(symmetric)協程了，它的特點是只有一種傳遞程式控制權的操作，即將控制權直接傳遞給指定的協程。曾經有這麼一種說法，對稱式和非對稱式協程機制的能力並不等價，但事實上很容易根據前者來實現後者。接下來我們就用代碼來證明這個事實。

--對稱式協程庫coro.lua

--代碼摘自論文"Coroutines in Lua"
--www.inf.puc-rio.br/~roberto/docs/corosblp.pdf

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提供的非對稱式協程不但具有與對稱式協程一樣強大的能力，而且還能避免程式員濫用機制寫出結構混亂的程式。