skynet skynet.start函数分析

注意:该文章暂且只分析skynet框架的lua层,底层待后续分析
首先知道 启动一个服务 必须调用 skynet.start函数 且服务间的调度必须通过消息的形式才能驱动

现在的代码都可在skynet.lua 中可以找到

//源码如下
function skynet.start(start_func)
	c.callback(skynet.dispatch_message)
	skynet.timeout(0, function()
		skynet.init_service(start_func)
	end)
end

该函数先注册了消息回调函数 skynet.dispatch_message
然后调用skynet.timeout

//timeout 实现
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 //绑定关系,后续raw_dispatch_message会用到
end

c.intcommand(“TIMEOUT”,ti) 向底层注册一个超时时间,此时 ti = 0,这个定时服务交由Timer线程处理
然后co_create(func) 创建一个协程

//co_create 实现
local function co_create(f)
	local co = table.remove(coroutine_pool)
	if co == nil then
		co = coroutine_create(function(...)
			f(...)
			local args = {...}
			skynet.error("co_create 128")
			for k,v in ipairs(args) do
				print(k,v)
			end
			while true do
				local session = session_coroutine_id[co]
				if session and session ~= 0 then
					local source = debug.getinfo(f,"S")
					skynet.error(string.format("Maybe forgot response session %s from %s : %s:%d",
						session,
						skynet.address(session_coroutine_address[co]),
						source.source, source.linedefined))
				end
				-- coroutine exit
				local tag = session_coroutine_tracetag[co]
				if tag ~= nil then
					if tag then c.trace(tag, "end")	end
					session_coroutine_tracetag[co] = nil
				end
				local address = session_coroutine_address[co]
				if address then
					release_watching(address)
					session_coroutine_id[co] = nil
				end

				-- recycle co into pool
				f = nil
				coroutine_pool[#coroutine_pool+1] = co
				-- recv new main function f
				f = coroutine_yield "SUSPEND"                                                            
				f(coroutine_yield())
			end
		end)
	else
		-- pass the main function f to coroutine, and restore running thread
		local running = running_thread
		coroutine_resume(co, f)
		running_thread = running
	end
	return co
end

当服务第一次启动时,coroutine_pool中是没有可用的协程的
timeout函数执行完后,Timer线程会给服务发送一个消息加到该服务的邮箱中,然后该消息会被放入到全局邮箱队列,等待工作线程调度,当工作线程调度是, 会调用该服务注册的消息处理函数skynet.dispatch_message (上面有提到)

//dispatch_message 实现
function skynet.dispatch_message(...)
	local succ, err = pcall(raw_dispatch_message,...)
	while true do
		local key,co = next(fork_queue)
		if co == nil then
			break
		end
		fork_queue[key] = nil
		local fork_succ, fork_err = pcall(suspend,co,coroutine_resume(co))
		if not fork_succ then
			if succ then
				succ = false
				err = tostring(fork_err)
			else
				err = tostring(err) .. "\n" .. tostring(fork_err)
			end
		end
	end
	assert(succ, tostring(err))
end

该函数会先调用 raw_dispatch_message函数

//raw_dispatch_message 实现
local function raw_dispatch_message(prototype, msg, sz, session, source)
	//此时底层Timer线程给服务发送的消息类型prototype = 1 msg = nil sz = 0
	-- skynet.PTYPE_RESPONSE = 1, read skynet.h
	if prototype == 1 then
		local co = session_id_coroutine[session]  //取到对应的协程
		if co == "BREAK" then
			session_id_coroutine[session] = nil
		elseif co == nil then
			unknown_response(session, source, msg, sz)
		else
			local tag = session_coroutine_tracetag[co]
			if tag then c.trace(tag, "resume") end
			session_id_coroutine[session] = nil
			suspend(co, coroutine_resume(co, true, msg, sz)) //唤醒协程co 传入参数true, msg, sz
		end
	else
		local p = proto[prototype]
		if p == nil then
			if prototype == skynet.PTYPE_TRACE then
				-- trace next request
				trace_source[source] = c.tostring(msg,sz)
			elseif session ~= 0 then
				c.send(source, skynet.PTYPE_ERROR, session, "")
			else
				unknown_request(session, source, msg, sz, prototype)
			end
			return
		end

		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)
			session_coroutine_id[co] = session
			session_coroutine_address[co] = source
			local traceflag = p.trace
			if traceflag == false then
				-- force off
				trace_source[source] = nil
				session_coroutine_tracetag[co] = false
			else
				local tag = trace_source[source]
				if tag then
					trace_source[source] = nil
					c.trace(tag, "request")
					session_coroutine_tracetag[co] = tag
				elseif traceflag then
					-- set running_thread for trace
					running_thread = co
					skynet.trace()
				end
			end
			suspend(co, coroutine_resume(co, session,source, p.unpack(msg,sz))) --解包数据
		else
			trace_source[source] = nil
			if session ~= 0 then
				c.send(source, skynet.PTYPE_ERROR, session, "")
			else
				unknown_request(session, source, msg, sz, proto[prototype].name)
			end
		end
	end
end

唤醒co时,会调用对应的function
然后往下调用到suspend 参数为co，true,SUSPEND
suspend(co, coroutine_resume(co, session,source, p.unpack(msg,sz)))

-- suspend is local function
function suspend(co, result, command, param, param2)
	skynet.error(skynet.address(skynet.self()), result, command, param, param2)
	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
				local tag = session_coroutine_tracetag[co]
				if tag then c.trace(tag, "error") end
				c.send(addr, skynet.PTYPE_ERROR, session, "")
			end
			session_coroutine_id[co] = nil
			session_coroutine_address[co] = nil
			session_coroutine_tracetag[co] = nil
		end
		error(debug.traceback(co,tostring(command)))
	end
	if command == "SUSPEND" then  --由传入的参数可知 会跑到这里
		dispatch_wakeup() --检测wakeup_queue列表,唤醒对应co 后续讲到 这里wakeup_queue为空 
		dispatch_error_queue()
	elseif command == "QUIT" then
		-- service exit
		return
	elseif command == "USER" then
		-- See skynet.coutine for detail
		error("Call skynet.coroutine.yield out of skynet.coroutine.resume\n" .. debug.traceback(co))
	elseif command == nil then
		skynet.error("co:",co)
		-- debug trace
		return
	else
		error("Unknown command : " .. command .. "\n" .. debug.traceback(co))
	end
end

流程是：调用skynet.start ------ 注册消息回调 skynet.dispatch_message -----调用skynet.timeout -----创建协程 ------ Timer线程消息回调 ------ 调用skynet.dispatch_message ------调用 raw_dispatch_message 唤醒线程------调用服务绑定的function – 调用suspend 处理其他逻辑