请教一个ltask的问题

[constly]

我在一个函数里面写了下面三行代码

local serviceId = ltask.spawn("sims.s.server|entry", ltask.self())
ltask.send(serviceId , "func1", tbParam)
ltask.send(serviceId , "func2", tbParam)

其中func1的逻辑比较重（还涉及到IO操作），func2的逻辑比较少
我发现 func1 和 func2好像是并行执行的，如果分别在里面加入print语句，func2里面的输出还会出现在func1前面。

这是正常的吗 = =
这种情况下，我也不太想用call，因为call会阻塞当前vm，直到返回

[actboy168]

同一个service，任何一个时刻都只会在其中一个物理线程上运行。这可能就是你认为的并行，如果你需要让多个物理线程同时工作，你需要多个service。

但是一个service可以有多个continue, call只是阻塞了当前的continue，并不会阻塞service(service和vm是等价的)。

[constly]

我的意思是，在func1没执行结束的情况下，func2就开始执行了，我在下面构造了一个可以复现的场景。

[constly]

不好意思，我之前提问题时，老眼昏花，少打了几个关键字，现在补上了 = =

[constly]

我尝试出了一个最小复现模型：

service1 的代码

local serviceId = ltask.spawn("service2", ltask.self())
ltask.send(serviceId , "func1")
ltask.send(serviceId , "func2")
ltask.send(serviceId , "print")

service2 的代码

local S = {}
local a = ""
function S.func1()
   a = a ..  "1"
   require 'meta'   -- 这里很关键，一定是require一个之前没被加载的文件
   a = a ..  "2"
end

function S.func2()
   a = a ..  "3"
end

function S.print()
   print("a is", a)
end

我这里最终输出是: a is 13
讲道理，我觉得正常情况下应该输出: a is 123

[constly]

先睡觉，明天再研究看看

[cloudwu]

这是因为 require 会发生 io ，而 io 导致 func1 挂起，它的后续就会排在 func2 的后面。

如果你需要一个服务中响应请求严格按全部做完一个再开始下一个，可以做一点点封装：做一个队列，每个请求收到后就立刻入队列。

[cloudwu]

我随手写一个给你看看，你可以完善它：

local task_queue = {}

local function add_task(f, ...)
	local tail = task_queue.t
	if tail then
		task_queue[tail] = table.pack( f, ... )
		task_queue.t = tail + 1
	else
		-- empty
		task_queue.h = 1
		task_queue.t = 1
		f(...)
		while task_queue.h < task_queue.t do
			local h = task_queue.h
			local task = task_queue[h]
			task_queue[h] = nil
			task_queue.h = h + 1
			task[1](table.unpack(task, 2, task.n))			
		end
		task_queue.h = nil
		task_queue.t = nil
	end
end

local QUEUE = setmetatable({}, {
	__newindex = function(_, name, f)
		S[name] = function(...)
			add_task(f, ...)
		end
	end })

接下来，你就可以利用 QUEUE 定义按队列依次执行的请求：

function QUEUE.func1(v)
	print("func1 begin", v)
	ltask.sleep(10)
	print("func1 end", v)
end

function QUEUE.func2()
	print("func2")
end

可以测试从另一个服务中触发它们：

ltask.send(addr, "func1", "before func2")
ltask.send(addr, "func2")
ltask.send(addr, "func1", "after func2")

[constly]

噢，这个问题还可以这样解决！ 学习了，非常感谢！

[cloudwu]

如果有更复的情况，比如这些请求还需要回应，需要做更多工作。不过如果你要回应，就会用 call 调用了。而在同一个服务 call 另外一个，本身也能保证次序。

[constly]

如果有更复的情况，比如这些请求还需要回应，需要做更多工作。不过如果你要回应，就会用 call 调用了。而在同一个服务 call 另外一个，本身也能保证次序。

这里我想再请教下：

1. 假如我在service1中call service2时，service2正处于sleep中，是否会等到sleep结束才会真正执行并返回，因为我这边典型的写法是每秒固定更新20帧之类的，多余时间就sleep，所以比较关注这点

local function update()
	while not quit do 		
                -- update
		ltask.sleep(20)
	end
	ltask.wakeup(quit)
end
ltask.fork(update)

[constly]

不过上面这个问题，我倒是可以自己测试下看

[constly]

不好意思，我吃饭时想了下，是我弄混了，上面的sleep是针对update那个协程的，与call本身没啥关系