今天听说了腾讯一个很牛逼的技术, 求问是怎么实现的

xphh2008

不就是协程么。

楼上有个喷lua的请自重，lua是非对称协程，但不代表是阻塞的。

wlmqgzm

请参考
Async MySQL Queries with C-API
http    jan.kneschke.de/2008/9/9/async-mysql-queries-with-c-api

starwing83

回复 30# Fixend


    怎么会呢？Lua的协程是异常强大的，我就举个简单的例子，假设你想递归地访问一个表，通常的写法是这样的：

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)
    

复制代码

可是，如果你打算一次取一个值，去做一些很复杂的操作（特别的，会涉及到上下文的操作），比如说，求一下这些值的和，比较简单的做法就是闭包加upvalue：

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

复制代码

问题是，如果我这里的处理流程就要求我，这个地方能一个一个地取值怎么办？

C/C++的办法是写一个迭代器，自己模拟栈，这很麻烦，而且需要技巧，但是Lua里面简单到爆了：

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
   

复制代码

其实非常简单，coroutine.wrap将一个函数转换成协程，每次调用都会resume，而回调只需要简单地设置为yield即可。

这就是协程改变操作流程的强大所在，它能在用代码表示的，复杂的操作流程中插入tag，然后在其他地方去监听这些tag，从而把一个复杂的递归过程变成线性的。

实际的应用，可以考虑看看我的一个Lua扩展模块，luasched：https://github.com/starwing/luasched

starwing83

回复 28# cokeboL


    擦，上面的帖子是回复你的，我回复错人了！！

恩，不管了，既然回错了，我就顺便举个例子吧。比如说，回调模式，我想买五个道具：

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
   

复制代码

一个超级简单的需求就这样成了递归函数了= =
那么，如果用协程呢？

假设我有个函数叫buyCO，他不是接受回调，而是在内部yield，那么我大可以这么写：

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

复制代码

就这样就可以了，task会保证这个函数会在“适当的时候”执行。简单吧？

cokeboL

回复 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)

复制代码

这两种写法，我个人觉得下面的更简洁，逻辑也比较直接，trace内部也是一个一个callback
用coroutine多写了点看上去很屌的代码，但看上去未必直接，关键是，yield给其他地方再回来，跟回调去调用别个再回来没本质区别，
而且单线程的，并没有带来异步的好处，回调反倒可以在c/c++层做异步的事情来提高效率

cokeboL

回复 41# xphh2008


    我说阻塞的意思是，lua为单线程，yield之后其实跟调用其他函数等调用完再回来没本质区别，都是上厕所排队，没有带来异步的好处，参考楼上帖

yulihua49

cokeboL 发表于 2015-05-12 09:13
回复 41# xphh2008

如果是单线程，是否yield之后，线程可以给别的客户端服务了？
如果是在多客户端的服务器里。

没弄明白，lua是怎么设定resume的条件的？

在C里边，都是在yield之前先准备好resume的条件。

cokeboL

回复 47# yulihua49


    不知道。。。最初开始学lua看到协程的时候，我就个人判定lua的协程是个鸡肋的东西，再没深入研究

   

windoze

回复 47# yulihua49

就是那个iter，coroutine写iter是yield，外面读iter是resume

cokeboL

回复 47# yulihua49


golang这种语言级实现的并发协程才好用，不需要去做任务线程、队列、回调之类的

传统的进程池、线程池调度开销大，goroutine开销小得多，就可以搞成池，比如
每个连接一个goroutine，然后1对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.         //绑定端口号
    
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("监听端口失败:", 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("客户端发来数据:", string(data[0:i]))
    
42.                                 if err != nil {
    
43.                                         fmt.Println("读取客户端数据错误:", 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. }
    

复制代码

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("连接服务端失败:", err.Error())
    
18.                 return
    
19.         }
    
20.         fmt.Println("已连接服务器")
    
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("请输入要发送的消息:")
    
29.                 _, err := fmt.Scan(&sms)
    
30.                 if err != nil {
    
31.                         fmt.Println("数据输入异常:", 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("读取服务器数据异常:", err.Error())
    
38.                 }
    
39.                 fmt.Println(string(buf[0:c]))
    
40.         }
    
41. 
    
42. }
    

复制代码