Lua 嵌套协程

我正在尝试在 copas 中使用 redis-lua 库。它需要一些修补。一个问题是 redis-lua 将一些迭代器定义为协程，但这些迭代器执行的网络操作可以yield。

因此，coroutine.yield用于两个非常不同的事情：迭代器和 copas。由于网络调用嵌套在迭代器中，因此网络收益由迭代器的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 s（见下文）来制作一个小示例，但它与现有代码不兼容。我可以不修改 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

有没有更好的解决方案？

Lua 协程总是让位于它们从中恢复的最后一个线程。Copas 套接字函数希望返回 Copas 事件循环，但它们却被用于实现 redis-lua 迭代器的协程卡住了。不幸的是，除了更改 redis-lua 迭代器的代码之外，您无能为力来解决这个问题。还没有人这样做的原因是，在Lua 5.2（LuaJIT也可以做到这一点）之前，它甚至不可能从迭代器函数中产生（迭代器在redis-lua中产生很好，因为它们永远不会离开迭代器函数，但你不能像Copas套接字函数那样超出for循环）。

您关于使用标签值将迭代器产量与其他生成区分开来的想法很好。您只需要确保将所有不适用于迭代器函数的收益传递给协程，包括 coroutine.yield 和 coroutine.resume 的任何参数/返回值（后者在调用 coroutine.wrap ed 函数时是隐式的）。

更具体地说，如果你在 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 ) -- mark all iterator yields
  end
  return ITERATOR_TAG -- returns are also intended for the iterator
end )
return function()
  return pass_yields( co_func, co_func() ) -- initial resume of the iterator
end

ITERATOR_TAG和pass_yields函数位于redis.lua顶部附近：

local ITERATOR_TAG = {} -- unique value to mark yields/returns
local function pass_yields( co_func, ... )
  if ... == ITERATOR_TAG then -- yield (or return) intended for iterator?
    return select( 2, ... ) -- strip the ITERATOR_TAG from results and return
  else
    -- pass other yields/resumes back and forth until we hit another iterator
    -- yield (or return); using tail recursion here instead of a loop makes
    -- handling vararg lists easier.
    return pass_yields( co_func, co_func( coroutine.yield( ... ) ) ) 
  end
end

AFAIK，redis-lua开发人员计划在今年年底之前标记另一个版本，因此他们可能会感谢拉取请求。

在您的第一个示例中，您使用的是 wrap(loop) .我想这是科帕斯的wrap，因为这个代码中没有提到科帕斯......

但是，您应该copas.wrap()一个插座，但您的loop是一个函数！

有关良好的介绍，请参阅copas文档。

相关内容

最新更新

热门标签：