今天聽說了騰訊一個(gè)很牛逼的技術(shù), 求問是怎么實(shí)現(xiàn)的

xphh2008

不就是協(xié)程么。

樓上有個(gè)噴lua的請(qǐng)自重，lua是非對(duì)稱協(xié)程，但不代表是阻塞的。

wlmqgzm

請(qǐng)參考
Async MySQL Queries with C-API
http    jan.kneschke.de/2008/9/9/async-mysql-queries-with-c-api

starwing83

回復(fù) 30# Fixend


    怎么會(huì)呢？Lua的協(xié)程是異常強(qiáng)大的，我就舉個(gè)簡(jiǎn)單的例子，假設(shè)你想遞歸地訪問一個(gè)表，通常的寫法是這樣的：

1. 
   
2. local function trace(t, f)
   
3.    for i, v in ipairs(t) do
   
4.       if type(v) == "table" then
   
5.          trace(v, f)
   
6.       else
   
7.          f(v)
   
8.       end
   
9.    end
   
10. end
    
11. 
    
12. trace({1,2,3,{4,5,{6,7,8}},9,{10}}, print)
    

復(fù)制代碼

可是，如果你打算一次取一個(gè)值，去做一些很復(fù)雜的操作（特別的，會(huì)涉及到上下文的操作），比如說，求一下這些值的和，比較簡(jiǎn)單的做法就是閉包加upvalue：

1. 
   
2. local count = 0
   
3. trace({......}, function() count = count + 1 end)
   

復(fù)制代碼

問題是，如果我這里的處理流程就要求我，這個(gè)地方能一個(gè)一個(gè)地取值怎么辦？

C/C++的辦法是寫一個(gè)迭代器，自己模擬棧，這很麻煩，而且需要技巧，但是Lua里面簡(jiǎn)單到爆了：

1. 
   
2. local iter = coroutine.wrap(function(t) trace(t, coroutine.yield) end)
   
3. for v in iter,t do
   
4.    print(v)
   
5. end
   

復(fù)制代碼

其實(shí)非常簡(jiǎn)單，coroutine.wrap將一個(gè)函數(shù)轉(zhuǎn)換成協(xié)程，每次調(diào)用都會(huì)resume，而回調(diào)只需要簡(jiǎn)單地設(shè)置為yield即可。

這就是協(xié)程改變操作流程的強(qiáng)大所在，它能在用代碼表示的，復(fù)雜的操作流程中插入tag，然后在其他地方去監(jiān)聽這些tag，從而把一個(gè)復(fù)雜的遞歸過程變成線性的。

實(shí)際的應(yīng)用，可以考慮看看我的一個(gè)Lua擴(kuò)展模塊，luasched：https://github.com/starwing/luasched

starwing83

回復(fù) 28# cokeboL


    擦，上面的帖子是回復(fù)你的，我回復(fù)錯(cuò)人了�。�

恩，不管了，既然回錯(cuò)了，我就順便舉個(gè)例子吧。比如說，回調(diào)模式，我想買五個(gè)道具：

function buy(item, callback) ... end

怎么辦？

1. 
   
2. local function buy_times(n)
   
3.   buy(item, function()
   
4.     if n > 1 then
   
5.         buy_times(n-1)
   
6.     end
   
7.   end)
   
8. end
   

復(fù)制代碼

一個(gè)超級(jí)簡(jiǎn)單的需求就這樣成了遞歸函數(shù)了= =
那么，如果用協(xié)程呢？

假設(shè)我有個(gè)函數(shù)叫buyCO，他不是接受回調(diào)，而是在內(nèi)部yield，那么我大可以這么寫：

1. 
   
2. task.new(function(n)
   
3.    for i = 1, n do
   
4.       buyCO(item)
   
5.    end
   
6. end)
   

復(fù)制代碼

就這樣就可以了，task會(huì)保證這個(gè)函數(shù)會(huì)在“適當(dāng)?shù)臅r(shí)候”執(zhí)行。簡(jiǎn)單吧？

cokeboL

回復(fù) 44# starwing83

1. local iter = coroutine.wrap(function(t) trace(t, coroutine.yield) end)
   
2. for v in iter,tab do
   
3.    print(v)
   
4. end
   
5. 
   
6. trace(tab, function(v)
   
7.         print(v)
   
8. end)

復(fù)制代碼

這兩種寫法，我個(gè)人覺得下面的更簡(jiǎn)潔，邏輯也比較直接，trace內(nèi)部也是一個(gè)一個(gè)callback
用coroutine多寫了點(diǎn)看上去很屌的代碼，但看上去未必直接，關(guān)鍵是，yield給其他地方再回來，跟回調(diào)去調(diào)用別個(gè)再回來沒本質(zhì)區(qū)別，
而且單線程的，并沒有帶來異步的好處，回調(diào)反倒可以在c/c++層做異步的事情來提高效率

cokeboL

回復(fù) 41# xphh2008


    我說阻塞的意思是，lua為單線程，yield之后其實(shí)跟調(diào)用其他函數(shù)等調(diào)用完再回來沒本質(zhì)區(qū)別，都是上廁所排隊(duì)，沒有帶來異步的好處，參考樓上帖

yulihua49

cokeboL 發(fā)表于 2015-05-12 09:13
回復(fù) 41# xphh2008

如果是單線程，是否yield之后，線程可以給別的客戶端服務(wù)了？
如果是在多客戶端的服務(wù)器里。

沒弄明白，lua是怎么設(shè)定resume的條件的？

在C里邊，都是在yield之前先準(zhǔn)備好resume的條件。

cokeboL

回復(fù) 47# yulihua49


    不知道。。。最初開始學(xué)lua看到協(xié)程的時(shí)候，我就個(gè)人判定lua的協(xié)程是個(gè)雞肋的東西，再?zèng)]深入研究

   

windoze

回復(fù) 47# yulihua49

就是那個(gè)iter，coroutine寫iter是yield，外面讀iter是resume

cokeboL

回復(fù) 47# yulihua49


golang這種語言級(jí)實(shí)現(xiàn)的并發(fā)協(xié)程才好用，不需要去做任務(wù)線程、隊(duì)列、回調(diào)之類的

傳統(tǒng)的進(jìn)程池、線程池調(diào)度開銷大，goroutine開銷小得多，就可以搞成池，比如
每個(gè)連接一個(gè)goroutine，然后1對(duì)1的的處理，可以寫線性代碼了

隨便搜了兩段：

1. 
   
2. //server.go
   
3. 
   
4. package main
   
5. 
   
6. import (
   
7.         "fmt"
   
8.         "net"
   
9. )
   
10. 
    
11. const (
    
12.         //綁定IP地址
    
13.         ip = "127.0.0.1"
    
14.         //綁定端口號(hào)
    
15.         port = 3333
    
16. )
    
17. 
    
18. func main() {
    
19.         listen, err := net.ListenTCP("tcp", &net.TCPAddr{net.ParseIP(ip), port, ""})
    
20.         if err != nil {
    
21.                 fmt.Println("監(jiān)聽端口失敗:", err.Error())
    
22.                 return
    
23.         }
    
24.         fmt.Println("已初始化連接，等待客戶端連接...")
    
25.         Server(listen)
    
26. }
    
27. 
    
28. func Server(listen *net.TCPListener) {
    
29.         for {
    
30.                 conn, err := listen.AcceptTCP()
    
31.                 if err != nil {
    
32.                         fmt.Println("接受客戶端連接異常:", err.Error())
    
33.                         continue
    
34.                 }
    
35.                 fmt.Println("客戶端連接來自:", conn.RemoteAddr().String())
    
36.                 defer conn.Close()
    
37.                 go func() {
    
38.                         data := make([]byte, 10)
    
39.                         for {
    
40.                                 i, err := conn.Read(data)
    
41.                                 fmt.Println("客戶端發(fā)來數(shù)據(jù):", string(data[0:i]))
    
42.                                 if err != nil {
    
43.                                         fmt.Println("讀取客戶端數(shù)據(jù)錯(cuò)誤:", err.Error())
    
44.                                         break
    
45.                                 }
    
46.                                 if string(data[:i]) == "exit" {
    
47.                                         conn.Write([]byte{'e', 'x', 'i', 't'})
    
48.                                         conn.Close()
    
49.                                         break
    
50.                                 }
    
51.                                 conn.Write(data[0:i])
    
52.                         }
    
53.                 }()
    
54.         }
    
55. }
    

復(fù)制代碼

1. //client.go
   
2. 
   
3. package main
   
4. 
   
5. import (
   
6.         "fmt"
   
7.         "net"
   
8. )
   
9. 
   
10. const (
    
11.         addr = "127.0.0.1:3333"
    
12. )
    
13. 
    
14. func main() {
    
15.         conn, err := net.Dial("tcp", addr)
    
16.         if err != nil {
    
17.                 fmt.Println("連接服務(wù)端失敗:", err.Error())
    
18.                 return
    
19.         }
    
20.         fmt.Println("已連接服務(wù)器")
    
21.         defer conn.Close()
    
22.         Client(conn)
    
23. }
    
24. 
    
25. func Client(conn net.Conn) {
    
26.         sms := make([]byte, 1024)
    
27.         for {
    
28.                 fmt.Print("請(qǐng)輸入要發(fā)送的消息:")
    
29.                 _, err := fmt.Scan(&sms)
    
30.                 if err != nil {
    
31.                         fmt.Println("數(shù)據(jù)輸入異常:", err.Error())
    
32.                 }
    
33.                 conn.Write(sms)
    
34.                 buf := make([]byte, 1024)
    
35.                 c, err := conn.Read(buf)
    
36.                 if err != nil {
    
37.                         fmt.Println("讀取服務(wù)器數(shù)據(jù)異常:", err.Error())
    
38.                 }
    
39.                 fmt.Println(string(buf[0:c]))
    
40.         }
    
41. 
    
42. }
    

復(fù)制代碼