skynet是一个轻量级的游戏服务器框架。

简介

在skynet的体系中，服务是一个基础概念。通常，我们使用skynet.newservice来启动一个snlua服务。
那么，当我们写下local addr = skynet.newservice("test")这行代码时，系统是怎么运作的呢？
思考一下这些问题：

• 调用skynet.newservice会不会发生阻塞？
• 如果test服务在skynet.start时调用了skynet.exit，addr会是什么值？
• 如果test服务在skynet.start时出现错误，addr又会是什么值？
• test服务是不是一定要调用skynet.start？
• 如果要传一些复杂的参数，又要怎么做？

skynet.newservice的代码实现

--skynet/lualib/skynet.lua
function skynet.newservice(name, ...)
    return skynet.call(".launcher", "lua" , "LAUNCH", "snlua", name, ...)
end

skynet.newservice的代码很简单，只调用了一个skynet.call，而skynet.call是阻塞的，所以skynet.newservice也是阻塞的。
这个call发了一条lua消息给.launcher服务，接下来看看.launcher服务相关的代码：

--skynet/service/launcher.lua
local function launch_service(service, ...)
    local param = table.concat({...}, " ")
    local inst = skynet.launch(service, param)
    local session = skynet.context()
    local response = skynet.response()
    if inst then
        services[inst] = service .. " " .. param
        instance[inst] = response
        launch_session[inst] = session
    else
        response(false)
        return
    end
    return inst
end

function command.LAUNCH(_, service, ...)
    launch_service(service, ...)
    return NORET
end

这里又调用到skynet.launch，实际上是发了个LAUNCH指令到底层，这里创建了一个snlua服务：

--skynet/lualib/skynet/manager.lua
function skynet.launch(...)
    local addr = c.command("LAUNCH", table.concat({...}," "))
    if addr then
        return tonumber(string.sub(addr , 2), 16)
    end
end

要注意前面的.launcher服务的command.LAUNCH函数是忽略返回的，所以此时skynet.newservice还处于阻塞状态，等待.launcher的返回。
那什么时候会返回响应呢？

回到前面的launch_service函数，可以看到skynet.launch成功后并没有直接返回，而是生成一个响应函数response，存储在表instance中。
搜索这个instance，我们可以在command.LAUNCHOK中找到它的使用：

--skynet/service/launcher.lua
function command.LAUNCHOK(address)
    -- init notice
    local response = instance[address]
    if response then
        response(true, address)
        instance[address] = nil
        launch_session[address] = nil
    end

    return NORET
end

也就是说，要等到.launcher服务收到LAUNCHOK的指令之后，才会返回给newservice的调用者。
问题又来了，什么时候发送LAUNCHOK呢？答案是在skynet.init_service中。

而调用skynet.init_service的，一共有三个函数：

• skynet.start
• skynet.forward_type
• skynet.filter

所以，在服务的启动脚本中，我们必须调用这三个函数中的其中一个（通常都是skynet.start），否则的话，调用方永远都收不到返回的数据。
以在main服务中，创建新服务test为例，流程如下图所示：

skynet_service.png

新服务启动时，调用skynet.exit，调用者收到的addr是什么？

我们看一下skynet.exit:

--skynet/lualib/skynet.lua
function skynet.exit()
    fork_queue = { h = 1, t = 0 }   -- no fork coroutine can be execute after skynet.exit
    skynet.send(".launcher","lua","REMOVE",skynet.self(), false)

    --其他代码...
    --...
end

这里看到，新服务发送了REMOVE指令到.launcher服务，而.launcher对REMOVE的处理如下：

--skynet/service/launcher.lua
function command.REMOVE(_, handle, kill)
    services[handle] = nil
    local response = instance[handle]
    if response then
        -- instance is dead
        response(not kill)  -- return nil to caller of newservice, when kill == false
        instance[handle] = nil
        launch_session[handle] = nil
    end

    -- don't return (skynet.ret) because the handle may exit
    return NORET
end

对于刚启动的服务来说，这里会调用到对应的response，response需要两个参数，这里第一个参数是true，第二个参数为nil，而第二个参数是返回地址，也就是说，调用者收到的addr是nil值。

skynet_service_exit.png

新服务启动报错的话，又返回什么呢

新服务启动的时候，无论是用skynet.start还是skynet.forward_type，最终都是调用skynet.init_service，来看看代码：

--skynet/lualib/skynet.lua
function skynet.init_service(start)
    local function main()
        skynet_require.init_all()
        start()
    end
    local ok, err = xpcall(main, traceback)
    if not ok then
        skynet.error("init service failed: " .. tostring(err))
        skynet.send(".launcher","lua", "ERROR")
        skynet.exit()
    else
        skynet.send(".launcher","lua", "LAUNCHOK")
    end
end

可以看到，对start函数的调用，是通过xpcall来调用的，如果报错的话，会发送ERROR到.launcher服务。

--skynet/service/launcher.lua
function command.ERROR(address)
    -- see serivce-src/service_lua.c
    -- init failed
    local response = instance[address]
    if response then
        response(false)
        launch_session[address] = nil
        instance[address] = nil
    end
    services[address] = nil
    return NORET
end

这里response参数是false，response是skynet.response生成的一个函数，相关代码如下：

--skynet/lualib/skynet.lua
function skynet.response(pack)
    --其他代码...
    --...
    local function response(ok, ...)
        --其他代码...
        --...
        if ok then
            ret = c.send(co_address, skynet.PTYPE_RESPONSE, co_session, pack(...))
            if ret == false then
                -- If the package is too large, returns false. so we should report error back
                c.send(co_address, skynet.PTYPE_ERROR, co_session, "")
            end
        else
            ret = c.send(co_address, skynet.PTYPE_ERROR, co_session, "")
        end
        --其他代码...
        --...
    end
    --其他代码...
    --...

    return response
end

可以看到，当传入的ok是false的时候，会发送一个PTYPE_ERROR类型的消息给调用者。
而当我们require"skynet"时，对PTYPE_ERROR默认的处理函数是_error_dispatch，具体的流程可以看看源码，这里简而言之，就是调用call的那条协程会触发一个call fail的error。

所以，当新服务的启动函数出错时，在新服务中会报错，中断，而调用者在skynet.call()中也会报call fail的错，从而中断执行，也就不会有addr的返回了。

skynet_service_error.png

如果启动服务要传比较复杂的参数，要怎么做比较好

skynet.newservice(service_name, ...)后面是可以带多个参数的，但这些参数只能是数字或字符串，回看前面的skynet.launch的代码，里面是调用了c.command("LAUNCH", table.concat({...}," "))，这里可以看到，传递的参数通过table.concat打包成字符串，以空格隔开。如果我们的参数中带有空格，或者我们想要传个table，那就不支持了。
通常来说，我们可以先启动服务，在skynet.start中做些简单的功能，调用skynet.dispatch("lua", ...)来处理lua消息，通过lua消息来做初始化，这样就能传送复杂的参数了：

local addr  = skynet.newservice("test")
skynet.send(addr, "lua", "start", {address='0.0.0.0',port=8888,nodelay=true})

总结

现在，我们可以回答最初的问题了：

• 调用skynet.newservice会不会发生阻塞？

  • 会阻塞，如果服务没启动完，会一直等待下去。

• 如果test服务在start时调用了exit，addr会是什么值？

  • nil

• 如果test服务在start时出现错误，addr又会是什么值？

  • skynet.newservice会报错，没有返回值

• test服务是不是一定要调用skynet.start？

  • 不一定，也可以调用skynet.forward_type或skynet.filter

• 如果要传一些复杂的参数，又要怎么做？

  • 将服务的创建和启动分开，创建后发送lua消息初始化服务。

最后再思考一个问题：启动系统的时候，第一个服务又是什么时候启动的呢？答案可以看看这里：skynet 之 main 服务的启动