Skynet 服务创建流程
根据设计综述 Skynet 是为了让服务器充分利用多核优势，将不同的业务放在独立的执行环境中处理。
Skynet 核心功能是加载一个 C 模块（动态库），模块用数字 id 标识，作为其 handle ，模块被称为服务 service 。服务间可以自由发送消息。每个模块可以向 Skynet 框架注册一个 callback 函数，用来接收发给它的消息。
每个服务是被一个个消息驱动，当无消息时，服务处于挂起状态。每个服务拥有一个属于自己的消息队列，框架中存在一个全局队列负责调度处理服务所接收到的消息。
代码层面，Skynet 服务对应于数据结构 struct skynet_context ，其中重要字段如下。
1struct skynet_context { 2 void * instance; // 模块自定义数据 3 struct skynet_module * mod; // 框架模块数据 4 void * cb_ud; // 传给回调函数的自定义数据 5 skynet_cb cb; // 回调函数 6 struct message_queue * queue; // 消息队列，用于接收发送给服务的消息 7};
函数 skynet_context_new 用于创建服务，返回值表示此服务。
1// 参数 name: 服务名 2// 参数 param: 传递给服务的参数 3struct skynet_context * skynet_context_new(const char * name, const char *param);
服务调用函数 skynet_callback 用于向框架注册回调函数，处理接收到的消息。
1// 参数 context: 表示服务 2// 参数 ud: user data 表示自定义数据 3// 参数 cb: 表示回调函数 4void skynet_callback(struct skynet_context * context, void *ud, skynet_cb cb); 5 6// 参数 context: 表示服务 7// 参数 ud: user data 由 skynet_callback 指定 8// 参数 type: 消息类型 9// 参数 session: 由发送方指定，标识发送的消息 10// 参数 source: 表示发送方服务的地址 11// 参数 msg sz: 数据 12typedef int (*skynet_cb)(struct skynet_context * context, void *ud, int type, int session, uint32_t source, const void * msg, size_t sz);
函数 skynet_send 用于向服务发送消息。向一个服务发送消息就是向这个服务的消息队列中添加消息。
1// 参数 context: 表示服务 2// 参数 source: 表示发送方服务的地址，可为 0 3// 参数 destination: 表示接收方服务的地址 4// 参数 type: 消息类型 5// 参数 session: 用于发送方标识发送的消息，可为 0 6// 参数 data sz: 数据 7// 返回值 : session 8int skynet_send(struct skynet_context * context, uint32_t source, uint32_t destination , int type, int session, void * data, size_t sz);
C 服务
1// 参数 name: 服务名 2// 参数 param: 传递给服务的 c-style 字符串，以空白字符分割 3struct skynet_context * skynet_context_new(const char * name, const char *param) 4{ 5 struct skynet_module * mod = skynet_module_query(name); 6 // 执行 create 传递参数无 7 void *inst = skynet_module_instance_create(mod); 8 // 执行 init ，参数 param 是传递给服务的参数 9 int r = skynet_module_instance_init(mod, inst, ctx, param); 10} 11
函数 skynet_context_new 完成 C 服务的创建，一次函数调用即可完成。函数执行成功，返回的 context 便是创建的服务。创建过程中的初始化包含 create 和 init 流程，在 init 流程中调用 skynet_callback 注册回调函数。此后，服务创建完成，便可接收消息。
Lua 函数 skynet.launch 用于在 Lua 中创建 C 服务。
Lua 服务
Lua 服务本质上也是 C 服务，只是将 Lua 回调函数注册到 C 服务中，将对服务接收消息的处理移动到 Lua 中。完成此功能的 C 服务是 snlua 服务。
因此，创建 Lua 服务需要先创建 snlua 服务，然后在 Lua 中调用 skynet.start 将 Lua 回调函数注册到 C 服务中，skynet.start 函数执行完后，Lua 服务创建完成。
skynet.newservice 用于创建 Lua 服务。参数 name 是服务名，参数 ... 是传给服务的参数，需要是 Lua 中能被转换成字符串的值。
1function skynet.newservice(name, ...) 2 return skynet.call(".launcher", "lua" , "LAUNCH", "snlua", name, ...) 3end
skynet.newservice 流程如下。
- 当前服务向 launcher 服务发送请求，请求创建服务
name。 - launcher 服务创建新服务。
- 新服务创建完成后，
skynet.newservice返回新服务的地址。
具体的创建过程如下所示。
逻辑来到 launcher 服务 command.LAUNCH 函数（主要代码片段）。
1local function launch_service(service, ...) 2 local param = table.concat({...}, " ") 3 local inst = skynet.launch(service, param) 4 local response = skynet.response() 5 if inst then -- launch 成功 6 services[inst] = service .. " " .. param 7 instance[inst] = response 8 else -- launch 失败 9 response(false) 10 return 11 end 12 return inst 13end 14 15function command.LAUNCH(_, service, ...) 16 launch_service(service, ...) 17 return NORET 18end
command.LAUNCH 调用 launch_service 传递的参数依次是 ("snlua", name, ...) 与 skynet.newservice 传递的参数对应。 在 launch_service 函数中 service 变量是 "snlua" 而 param 变量是要创建的服务名及其参数。调用 skynet.launch 创建 C 服务 snlua 且将 param 传递给 snlua ，返回的 inst 是创建的地址。 创建成功记录数据到 services 和 instance 变量中，services 存储通过 launcher 服务创建的服务，instance 存储 skynet.response 用于回复请求方创建结果。
创建失败调用 response(false) 回复请求方创建失败。
新服务创建完成后，发送 LAUNCHOK 到 launcher 服务。launcher 服务回复请求方新服务的地址。
逻辑来到 C 服务 snlua ，模块是 service_snlua.c 。
snlua 服务的核心工作就是将消息处理回调函数对接到 Lua 中指定的回调函数。
snlua 服务首先执行 create 函数，调用 lua_newstate 创建 Lua 虚拟机。然后在 init 函数调用 skynet_callback 向框架注册回调函数，并向自身发送第一条消息，用于进行后续初始化。注意 args 参数是要创建的服务信息。
1// 参数 args: 字符串，包含由空白字符分割的多个字符串，第一个字符串是要创建的 Lua 服务名，参考 skynet.launch 的 param 参数 2int 3snlua_init(struct snlua *l, struct skynet_context *ctx, const char * args) { 4 int sz = strlen(args); 5 char * tmp = skynet_malloc(sz); 6 memcpy(tmp, args, sz); 7 // 1. 注册回调函数 launch_cb 8 skynet_callback(ctx, l , launch_cb); 9 // 2. 在第一条消息中进行后续初始化 10 const char * self = skynet_command(ctx, "REG", NULL); 11 uint32_t handle_id = strtoul(self+1, NULL, 16); 12 // it must be first message 13 skynet_send(ctx, 0, handle_id, PTYPE_TAG_DONTCOPY,0, tmp, sz); 14 return 0; 15} 16 17struct snlua * 18snlua_create(void) { 19 struct snlua * l = skynet_malloc(sizeof(*l)); 20 memset(l,0,sizeof(*l)); 21 l->L = lua_newstate(lalloc, l); // 创建 Lua 虚拟机 22 return l; 23}
问题：为何没有在 snlua_init 中直接调用 init_cb ？
乍一看，后续初始化逻辑 init_cb 可在 snlua_init 函数中完成，但这里设计成延迟到第一条消息中执行，好处是简化 snlua_init 函数逻辑，虽然增加了流程，但由于是在第一条消息中处理，整个过程是连续的，从框架整体来看，可认为此过程是“原子”的。对于这种复杂初始化流程，我也很认可这种设计，学习了。
在第一条消息中处理后续初始化。如果初始化失败，snlua 服务退出。
1// 参数 msg sz: 要创建的服务信息，参考 snlua_init 中 args 参数 2static int 3launch_cb(struct skynet_context * context, void *ud, int type, int session, uint32_t source , const void * msg, size_t sz) { 4 assert(type == 0 && session == 0); 5 struct snlua *l = ud; 6 skynet_callback(context, NULL, NULL); // 细节：先清空回调字段 7 int err = init_cb(l, context, msg, sz); 8 if (err) { 9 skynet_command(context, "EXIT", NULL); 10 } 11 return 0; 12}
Lua 服务具体的初始化逻辑如下。
1// 参数 args sz: 对应 launch_cb 中 msg sz 2static int 3init_cb(struct snlua *l, struct skynet_context *ctx, const char * args, size_t sz) { 4 lua_State *L = l->L; 5 l->ctx = ctx; 6 lua_gc(L, LUA_GCSTOP, 0); // 关闭 GC 7 lua_pushboolean(L, 1); /* signal for libraries to ignore env. vars. */ 8 lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); 9 luaL_openlibs(L); // 打开标准库 10 lua_pushlightuserdata(L, ctx); // 设置 struct skynet_context 11 lua_setfield(L, LUA_REGISTRYINDEX, "skynet_context"); 12 luaL_requiref(L, "skynet.codecache", codecache , 0); 13 lua_pop(L,1); 14 15 // 保存一些路径到如下全局变量中 16 const char *path = optstring(ctx, "lua_path","./lualib/?.lua;./lualib/?/init.lua"); 17 lua_pushstring(L, path); 18 lua_setglobal(L, "LUA_PATH"); 19 const char *cpath = optstring(ctx, "lua_cpath","./luaclib/?.so"); 20 lua_pushstring(L, cpath); 21 lua_setglobal(L, "LUA_CPATH"); 22 const char *service = optstring(ctx, "luaservice", "./service/?.lua"); 23 lua_pushstring(L, service); 24 lua_setglobal(L, "LUA_SERVICE"); 25 const char *preload = skynet_command(ctx, "GETENV", "preload"); 26 lua_pushstring(L, preload); 27 lua_setglobal(L, "LUA_PRELOAD"); 28 29 // 设置 traceback 函数 30 lua_pushcfunction(L, traceback); 31 assert(lua_gettop(L) == 1); 32 33 // 加载 Lua 服务入口脚本 34 const char * loader = optstring(ctx, "lualoader", "./lualib/loader.lua"); 35 int r = luaL_loadfile(L,loader); 36 if (r != LUA_OK) { 37 skynet_error(ctx, "Can't load %s : %s", loader, lua_tostring(L, -1)); 38 report_launcher_error(ctx); 39 return 1; 40 } 41 lua_pushlstring(L, args, sz); 42 r = lua_pcall(L,1,0,1); 43 if (r != LUA_OK) { 44 skynet_error(ctx, "lua loader error : %s", lua_tostring(L, -1)); 45 report_launcher_error(ctx); 46 return 1; 47 } 48 lua_settop(L,0); 49 50 // 处理 skynet.memlimit 设置的内存限制 51 if (lua_getfield(L, LUA_REGISTRYINDEX, "memlimit") == LUA_TNUMBER) { 52 size_t limit = lua_tointeger(L, -1); 53 l->mem_limit = limit; 54 skynet_error(ctx, "Set memory limit to %.2f M", (float)limit / (1024 * 1024)); 55 lua_pushnil(L); 56 lua_setfield(L, LUA_REGISTRYINDEX, "memlimit"); 57 } 58 lua_pop(L, 1); 59 60 lua_gc(L, LUA_GCRESTART, 0); // 重启 GC 61 return 0; 62}
函数 init_cb 的核心作用就是调用 lua_pcall 函数执行 Lua 服务入口脚本，脚本文件由 args sz 指定，具体实现有一些细节。
- 上述整个加载过程是关闭 Lua GC 的，完成后才重新启动 GC 。猜测是为了加快加载速度。
skynet.codecache用于在 Lua 虚拟机之间共享代码。- 调用
lua_pcall前设置了traceback函数。 - 通过
lualoader加载lualoader脚本，并传递args sz参数。 - snlua 服务中调用
skynet_callback(context, NULL, NULL);删除回调函数后，未再发现注册回调函数的 C 代码，此注册是在 Lua 中完成的。
执行 lua_pcall 函数，逻辑来到框架提供的 lualoader 脚本，位于 ./lualib/loader.lua 。
1-- ... 就是 C 函数 init_cb 中的 args sz 2local args = {} -- Lua 服务名及参数 3for word in string.gmatch(..., "%S+") do 4 table.insert(args, word) 5end 6SERVICE_NAME = args[1] -- 服务名 7 8-- 定位并加载 Lua 服务脚本文件 9local main, pattern -- 分别表示加载后的 Lua chunk 和 Lua 服务脚本文件路径 10local err = {} 11for pat in string.gmatch(LUA_SERVICE, "([^;]+);*") do 12 local filename = string.gsub(pat, "?", SERVICE_NAME) 13 local f, msg = loadfile(filename) 14 if not f then 15 table.insert(err, msg) 16 else 17 pattern = pat 18 main = f 19 break 20 end 21end 22 23-- 预处理，可选 24if LUA_PRELOAD then 25 local f = assert(loadfile(LUA_PRELOAD)) 26 f(table.unpack(args)) 27 LUA_PRELOAD = nil 28end 29-- 执行 Lua 服务入口脚本 30main(select(2, table.unpack(args)))
前面提到，需要在脚本调用 skynet.start 向框架注册 Lua 回调函数，完成创建 Lua 服务。lualoader 中调用 main 函数，执行 Lua 服务入口脚本，于是 skynet.start 函数被调用，Lua 服务创建完成。
skynet.start 函数中 c.callback(skynet.dispatch_message) 完成 Lua 回调函数的注册。
如下代码，skynet.start 执行完毕后，注册一个 0 秒定时器回调，那时调用 start_func 执行上层业务初始化，并根据初始化结果发送消息到 launcher 服务，告知创建成功与否。
1function skynet.start(start_func) 2 c.callback(skynet.dispatch_message) -- 注册 Lua 回调函数 3 -- 注册定时器回调处理上层业务初始化 4 init_thread = skynet.timeout(0, function() 5 skynet.init_service(start_func) 6 init_thread = nil 7 end) 8end 9 10function skynet.init_service(start) 11 -- 初始化上层业务，并告知 launcher 创建结果 12 local ok, err = skynet.pcall(start) 13 if not ok then 14 skynet.error("init service failed: " .. tostring(err)) 15 skynet.send(".launcher","lua", "ERROR") 16 skynet.exit() 17 else 18 skynet.send(".launcher","lua", "LAUNCHOK") 19 end 20end
注意，skynet.start 函数执行完后，在 Skynet 框架层面 Lua 服务已创建完成，可对外提供服务。
而 skynet.init_service 是在业务层面完成初始化，然后才通知 launcher 服务。
问题：为何没有在 skynet.start 中直接调用 skynet.init_service ?
先看调用链 snlua - init_cb() -> lua_pcall -> lualoader - main() -> skynet.start() 。skynet.start 调用堆栈是从 init_cb 函数触发，而 skynet.init_service 会调用上层业务初始化 start_func 函数，start_func 函数可能会很复杂，比如有 RPC ，在 skynet.start 函数中将 skynet.init_service 放到定时器回调中执行，可以将业务层初始化和框架层初始化分离，简化 init_cb 函数触发到脚本中的逻辑。学习了。
理解：在 Skynet 框架层面，创建服务的“原子”性。
对于 C 服务，一次 C 函数 skynet_context_new 调用完成创建，框架内部处理具体过程中的多线程临界区，但从框架层面来看，给这个服务发送消息，要么未查询到服务，要么查询到服务且此时服务是可接收消息的。
对于 Lua 服务，需要一次 C 函数 skynet_context_new 调用和第一条消息完成创建，虽然带有流程，但第一条消息保证了连续性，从框架层面来看，也满足给这个服务发送消息，要么未查询到服务，要么查询到服务且此时服务是可接收消息的。但 Lua 服务中，skynet.init_service 是在定时器回调中调用的，假设在此函数执行前，消息队列中已经存在其它消息，此时在 Lua raw_dispatch_message 函数中，如下代码片段，若 p == nil 则进行如下处理。
1local p = proto[prototype] 2if p == nil then 3 if session ~= 0 then 4 c.send(source, skynet.PTYPE_ERROR, session, "") 5 else 6 unknown_request(session, source, msg, sz, prototype) 7 end 8 return 9end
理解：函数 skynet.register_protocol 和 skynet.dispatch 调用时机。
此函数指定用于业务的消息处理函数。而 skynet.start 的参数 start_func 调用之前，可能已经接收到了消息。
因此，如果某类消息依赖于 start_func 进行初始化，则应该在 start_func 中才指定用于业务的消息处理函数。
如果某消息不依赖于 start_func ，则可和 skynet.start 的调用时机一样，指定消息处理函数。
理解：服务与 worker 线程。
Skynet 在启动 worker 线程之前，就创建了服务，并且可向此服务发送消息，只是 worker 线程开始工作后，才开始调度执行服务接收到的消息。