Lua嵌套协程

我正在尝试在copas中使用redis-lua库。它需要一些补丁。

一个问题是redis-lua将一些迭代器定义为协程,但这些迭代器执行可能会导致yield的网络操作。

所以,coroutine.yield被用于两个非常不同的事情:迭代器和copas。由于网络调用嵌套在迭代器中,网络yield被迭代器的coroutine.wrap拦截,而不是被copas拦截。

下面的例子显示了这个问题:

local function iterator ()
  for i = 1, 2 do
    if i == 2 then coroutine.yield () end -- network yield
    coroutine.yield () -- iterator yield
  end
end
local citerator = coroutine.wrap (iterator)

local function loop () -- use of the iterator within a copas thread
  while citerator () do end
end
local cloop = coroutine.create (loop)

while coroutine.resume (cloop) do end -- same as copas loop, executes the cloop thread

有没有解决这个问题的“标准”解决方案,仍然允许将协程用于迭代器?

我通过“标记”yield(见下文)使一个小例子工作,但它与现有代码不兼容。我可以让copas代码保持不变,但必须更新redis-lua中的迭代器。

local function wrap (f, my_tag)
  -- same as coroutine.wrap, but uses my_tag to yield again
  local co = coroutine.create (f)
  return function ()
    local t = table.pack (coroutine.resume (co))
    local code = t [1]
    local tag  = t [2]
    table.remove (t, 1)
    table.remove (t, 1)
    if tag == nil then
      return
    elseif my_tag == tag then
      return table.unpack (t)
    else
      coroutine.yield (tag, table.unpack (t))
    end
  end
end

local Iterator = {} -- tag for iterator yields
local Network  = {} -- tag for network yields

local function iterator ()
  for i = 1, 2 do
    if i == 2 then coroutine.yield (Network, i) end
    coroutine.yield (Iterator, i)
  end
end

local citerator = wrap (iterator, Iterator)

local function loop ()
  while citerator () do end
end

local cloop = wrap (loop, Network)

while cloop () do end

有没有更好的解决方案?

点赞
用户1183484
用户1183484

在你的第一个例子中,你使用了 wrap(loop)。我猜这是 copas 的 wrap,因为这段代码中没有引用 copas...

然而,你应该使用 copas.wrap() 包装一个 _socket_,但是你的 loop 是一个函数!

请参阅 copas 文档以获取很好的介绍

2014-11-25 16:12:58
用户3677376
用户3677376

Lua 协程总是返回到上次恢复的线程。Copas socket 函数期望返回到 Copas 事件循环,但实际上它们卡在用于实现 redis-lua 迭代器的协程上。不幸的是,你无法通过修复代码来解决这个问题,除非修改 redis-lua 迭代器的代码。之前没有人这样做的原因是直到 Lua 5.2(LuaJIT 也可以)才能从迭代器函数进行 yield(redis-lua 中的迭代器 yield 工作正常,因为它们从未离开迭代器函数,但是你不能进行 for 循环的 yield,就像 Copas socket 函数尝试做的那样)。

你关于使用标记值区分迭代器 yield 和其它 yield 的想法是好的。你只需确保将所有不用于迭代器函数的 yield 传递给上一层协程,包括 coroutine.yieldcoroutine.resume 的任何参数/返回值(后者在调用 coroutine.wrap 包装的函数时是隐式的)。

具体来说,如果你在 redis-lua 中有以下代码:

-- ...
return coroutine.wrap( function()
  -- ...
  while true do
    -- ...
    coroutine.yield( some_values )
  end
end )

你应该将其改为:

-- ...
local co_func = coroutine.wrap( function()
  -- ...
  while true do
    -- ...
    coroutine.yield( ITERATOR_TAG, some_values ) -- 标记所有迭代器 yield
  end
  return ITERATOR_TAG -- 返回结果也是迭代器的
end )
return function()
  return pass_yields( co_func, co_func() ) -- 迭代器的初始恢复
end

ITERATOR_TAGpass_yields 函数会放在 redis.lua 的顶部:

local ITERATOR_TAG = {} -- 用于标记 yield/return 的唯一值

local function pass_yields( co_func, ... )
  if ... == ITERATOR_TAG then -- 是否为迭代器的 yield(或 return)?
    return select( 2, ... ) -- 从结果中去除 ITERATOR_TAG 并返回
  else
    -- 将其它 yield/resume 传递回去,直到遇到另一个迭代器 yield(或 return);
    -- 在此使用尾递归而不是循环,使处理可变参数列表更容易。
    return pass_yields( co_func, co_func( coroutine.yield( ... ) ) )
  end
end

据我所知,redis-lua 开发人员计划在年底前发布另一个版本,所以他们可能会感谢 pull requests。

2014-11-26 02:26:35