skynet源码分析之lua层消息处理

Lua层消息处理机制在lualib/skynet.lua，提供大部分Lua层的api（最终会调用到c层的api），包括启动一个snlua服务时Lua层的处理，创建新服务，注册服务协议，如何发送消息，如何处理对方发过来的消息等。本篇主要介绍消息处理机制，从而理解skynet如何实现高并发。

为了简化，代码里用到的coroutine_resume，coroutine_yield看成coroutine.resume，coroutine.yield即可。

local coroutine_resume = profile.resume
local coroutine_yield = profile.yield

1. 协程

coroutine.create，创建一个co，唯一的参数是co要执行的闭包f，此时是不会执行闭包f的

coroutine.resume，执行一个co，第一个参数是co的句柄，如果是第一次执行，其他参数是传递给闭包f的。co启动后，一直执行直到它终止或让出。正常终止，返回true和闭包f的返回值；发生错误异常终止，则返回false和错误信息

coroutine.yield，使co暂停，让出执行权。对应最近的resume会立刻返回，返回true和yield的参数。下一次resume同一个co时，会从让出点继续执行，此时，yield的调用会立刻返回，返回值为resume除第一个参数之外的其他参数

引用Lua文档介绍协程coroutine(简称co)的经典例子，可以看出，co可以被不断的暂停和重启。skynet广泛使用co，当发送一个rpc请求时会暂停当前co，等对方返回时又重启co。

 

2. skynet创建协程的方式

先阐述下skynet创建协程(co)的方式，通过co_create(f)这个api创建一个协程，这段代码非常有意思。为了性能，skynet会把创建的co放到缓存里(第9行)，当协程执行完流程(闭包f)后不会终止，而是暂停(第10行)。当调用者调用co_create这个api时，如果缓存里没有，通过coroutine.create创建一个co，此时是不会执行闭包f，然后在某个时刻(通常是收到消息调用消息分发skynet.dispatch_message)会重启(附带需要的参数)这个co，co接着执行闭包f(第6行)，最后暂停以等待下一次使用，对应最近的resume返回true和“EXIT”(第10行)；如果是一个复用的co，重启co(第15行，参数是将要执行的闭包f)，yield会立刻返回把闭包赋值给f(第10行)，在11行又暂停，同样在某个时刻会重启(附带需要的参数)这个co，co接着执行闭包f(第11行)，最后又在第10行暂停等待下一次使用。

-- lualib/skynet.lua
local function co_create(f)
    local co = table.remove(coroutine_pool)
    if co == nil then
        co = coroutine.create(function(...)
            f(...)
            while true do
                f = nil
                coroutine_pool[#coroutine_pool+1] = co
                f = coroutine_yield "EXIT"
                f(coroutine_yield())
            end
        end)
    else
        coroutine_resume(co, f)
    end
    return co
end

3. 如何处理Lua层消息  

了解了co_create的原理后，接下来以服务A向服务B发一条消息为例说明skynet是如何处理Lua层消息：

-- A.lua
local skynet = require "skynet"

skynet.start(function()
    print(skynet.call("B", "lua", "aaa"))
end)

-- B.lua
local skynet = require "skynet"
require "skynet.manager"

skynet.start(function()
    skynet.dispatch("lua", function(session, source, ...)
        skynet.ret(skynet.pack("OK"))
    end)
    skynet.register "B"
end)

 在服务启动最后会调用skynet.start，skynet.start调用skynet.timeout，在timeout里会创建一个co(12行)，称之为服务的主协程co1，此时co1不会执行

 -- lualib/skynet.lua
 function skynet.start(start_func)
     c.callback(skynet.dispatch_message)
     skynet.timeout(0, function()
         skynet.init_service(start_func)
     end)
 end
 
 function skynet.timeout(ti, func)
     local session = c.intcommand("TIMEOUT",ti)
     assert(session)
     local co = co_create(func)
     assert(session_id_coroutine[session] == nil)
     session_id_coroutine[session] = co
 end

定时器被触发（因为定时器设置是0，所以下一帧就触发）会向服务发送一条“RESPONSE”类型(PTYPE_RESPONSE=1)的消息

// skynet-src/skynet_timer.c
static inline void
dispatch_list(struct timer_node *current) {
    ...
    message.sz = (size_t)PTYPE_RESPONSE << MESSAGE_TYPE_SHIFT;
    ...
}

 服务收到消息后，调用消息分发api，由于消息类型是RESPONSE，最终会执行到第7行。重启主协程co1，执行co1的闭包f(这里是skynet.init_service(start_func))，如果闭包f里没有暂停的操作，待闭包f成功运行完，co1暂停，resume会返回true和"EXIT"，接下来，第7行就变成，suspend(co, true, "EXIT")

-- luablib/skynet.lua
local function raw_dispatch_message(prototype, msg, sz, session, source)
    -- skynet.PTYPE_RESPONSE = 1, read skynet.h
    if prototype == 1 then
        local co = session_id_coroutine[session]
        ...
        suspend(co, coroutine_resume(co, true, msg, sz))
    ...
end

然后，调用suspend，由于类型是"EXIT"，做一些清理工作即可。

-- lualib/skynet.lua
function suspend(co, result, command, param, size)
    ...
    elseif command == "EXIT" then
        -- coroutine exit
        local address = session_coroutine_address[co]
        if address then
            release_watching(address)
            session_coroutine_id[co] = nil
            session_coroutine_address[co] = nil
            session_response[co] = nil
        end
    ...
end

当闭包f里有暂停操作，比如A服务向B服务发送消息skynet.call("B", "lua", "aaa")，这里分别讲解A服务和B服务是如何处理的：

对于A服务：

首先在c层把消息发送出去（第14行，把消息push到目的服务的次级消息队列），然后暂停co1，resume返回true，"CALL"和session值

-- lualib/skynet.lua
local function yield_call(service, session)
    watching_session[session] = service
    local succ, msg, sz = coroutine_yield("CALL", session)
    watching_session[session] = nil
    if not succ then
        error "call failed"
    end
    return msg,sz
end

function skynet.call(addr, typename, ...)
    local p = proto[typename]
    local session = c.send(addr, p.id , nil , p.pack(...))
    if session == nil then
        error("call to invalid address " .. skynet.address(addr))
    end
    return p.unpack(yield_call(addr, session))
end

 然后调用suspend(co, true, "CALL", session)，类型是"CALL"，以session为key，co为value保存在session_id_coroutine里，以便当B服务对A的请求返回后，根据session找到对应的co，从而可以重启co

-- lualib/skynet.lua
function suspend(co, result, command, param, size)
    ...
    if command == "CALL" then
        session_id_coroutine[param] = co
    ...
end

当A收到B的返回消息时，调用消息分发api，根据session找到对应的co(即主协程co1)，从上一次暂停点重启它，下面这一行代码yield会立刻返回，打印出B返回的结果print(...)(A.lua)，此时执行完co1整个流程，返回true和“EXIT”给suspend，对co1做一些清理工作。

local succ, msg, sz = coroutine_yield("CALL", session)

稍微改一下A.lua，co1执行闭包f流程中通过fork创建一个协程（称为co2），由于co1没有暂停，会一直执行完整个流程。此时co2并没有执行。 

-- A.lua
local skynet = require "skynet"

skynet.start(function()
    skynet.fork(function()
        print(skynet.call("B", "lua", "aaa"))
    end)
end)

-- lualib/skynet.lua
function skynet.fork(func,...)
    local args = table.pack(...)
    local co = co_create(function()
        func(table.unpack(args,1,args.n))
    end)
    table.insert(fork_queue, co)
    return co
end

消息分发api做的第二件事是处理fork_queue里的co。所以收到定时器发送回来的消息后做的第二件事是重启co2，向B服务发送消息后暂停co2，直到B返回时再重启co2。

-- lualib/skynet.lua
function skynet.dispatch_message(...)
    ...    
    local fork_succ, fork_err = pcall(suspend,co,coroutine_resume(co))
    ...
end

对于B服务：

 收到A服务的消息后调用消息分发api，创建一个co(第12行)，co要执行的闭包f是已注册的消息回调函数p.dispatch(第4行)，然后通过resume重启它(第15行)

-- lualib/skynet.lua
local function raw_dispatch_message(prototype, msg, sz, session, source)
    ...    
    local f = p.dispatch
    if f then
        local ref = watching_service[source]
        if ref then
            watching_service[source] = ref + 1
        else
            watching_service[source] = 1
        end
            local co = co_create(f)
13　　　　　　　　session_coroutine_id[co] = session
            session_coroutine_address[co] = source
            suspend(co, coroutine_resume(co, session,source, p.unpack(msg,sz)))
    ...
end

执行skynet.ret(skynet.pack("OK"))，调用yield暂停它(第4行)，最近的resume返回，上面第15行变成suspend(co, true, "RETURN", msg, sz)

-- lualib/skynet.lua
function skynet.ret(msg, sz)
    msg = msg or ""
    return coroutine_yield("RETURN", msg, sz)
end

 当command=="RETURN"时，做两件事：1. 向源地址（即A服务）发送返回消息（第5行）；2. 重启co（第7行），co从skynet.ret返回，然后B服务的消息回调函数（p.dispatch）执行完，co的闭包f全部执行完放入缓存中，返回true和“EXIT“给suspend

-- lualib/skynet.lua
function suspend(co, result, command, param, size) 
    ...     
    elseif command == "RETURN" then
        ret = c.send(co_address, skynet.PTYPE_RESPONSE, co_session, param, size) ~= nil
        ...
        return suspend(co, coroutine_resume(co, ret))
    ...
end

至此，就是Lua层消息处理的整个流程。

4. 异常处理

在一些情况下需要做异常处理，比如没有注册对应消息类型的协议，没有提供消息回调函数，执行co过程中发生错误等。当一个服务处理一条消息的过程发生异常，必须要做两件事：1. 异常终止当前co；2. 通知消息发送方，而不是让对方一直忙等待。

当执行co过程中发生错误时，resume第一个返回值是false，调用suspend，向对方发送一条PTYPE_ERROR类型消息（第9行），然后抛出异常，终止当前co（第14行）。

-- lualib/skynet.lua
function suspend(co, result, command, param, size)
    if not result then
        local session = session_coroutine_id[co]
        if session then -- coroutine may fork by others (session is nil)
            local addr = session_coroutine_address[co]
            if session ~= 0 then
                -- only call response error
                c.send(addr, skynet.PTYPE_ERROR, session, "")
            end
            session_coroutine_id[co] = nil
            session_coroutine_address[co] = nil
        end
        error(debug.traceback(co,tostring(command)))
    end
    ...
end

大部分异常情况下，都会向对方发送一条PTYPE_ERROR类型消息通知对方，当收到PYTPE_ERROR类型消息，会调用_error_dispatch，把error_source记录在dead_service里，把error_session记录在error_queue里

-- lualib/skynet.lua
local function _error_dispatch(error_session, error_source)
    if error_session == 0 then
        -- service is down
        --  Don't remove from watching_service , because user may call dead service
        if watching_service[error_source] then
             dead_service[error_source] = true
        end
        for session, srv in pairs(watching_session) do
            if srv == error_source then
                table.insert(error_queue, session)
            end
        end
    else
        -- capture an error for error_session
        if watching_session[error_session] then
            table.insert(error_queue, error_session)
        end
    end
end

在suspend最后会调用dispatch_error_queue处理error_queue，通过session查找到正在等待的co，然后强制终止它，保证co不会一直忙等待。

-- lualib/skynet.lua
local function dispatch_error_queue()
    local session = table.remove(error_queue,1)
    if session then
        local co = session_id_coroutine[session]
        session_id_coroutine[session] = nil
        return suspend(co, coroutine_resume(co, false))
    end
end

5. 总结

一次同步的rpc请求的流程如下图。当一个服务当前co暂停时，可以去执行服务里其他co的流程，N个co之间可以交叉执行，一个co暂停并不会影响其他co的执行，最大化提供计算能力，实现高并发。