Python 3.x 如何收集结果并将limit与父子函数一起使用

我试图实现的是产生多个父代，每个父代做一些工作，然后产生几个子代来检查其他事情，并在父代中获取这些结果来做进一步的工作。 我还尝试了两种不同的繁殖限制，因为父母的工作比孩子的工作做得更多

我将如何做到这一点

如果我不使用limit2，它会工作，但我希望有两个限制器

importtrio
进口要求
导入时间
随机输入
异步def子级（父级、i、发送方、限制2）：
与limit2异步：
打印（'Parent{0}，Child{1}:已开始！正在睡眠…'。格式（Parent，i））
#等待三重奏。睡眠（随机。随机范围（0，3））
打印（'Parent{0}，Child{1}：正在退出！'.format（Parent，i））
与发送方异步：
wait sender.send（'Parent{0}，Child{1}：正在退出！'.format（Parent，i））
异步def父级（i，限制）：
与限制异步：
打印（'Parent{0}:已开始！正在睡眠…'。格式（i））
#等待三重奏。睡眠（随机。随机范围（0，3））
发送器、接收器=三个。打开存储通道（10）
limit2=三线电容限位器（2）
与trio.open_托儿所（）异步作为托儿所：
对于范围（10）内的j：
托儿所。尽快开始（孩子、i、j、寄件人、limit2）
与接收器异步：
接收器中值的异步：
打印（'获取值：{！r}'。格式（值））
打印（'Parent{0}:正在退出！'。格式（i））
异步def main（）：
极限=三个电容限位器（1）
与trio.open_托儿所（）异步作为托儿所：
对于范围（1）中的i：
托儿所。尽快开始（家长、我、限制）
如果名称=“\uuuuu main\uuuuuuuu”：
开始时间=时间。性能计数器（）
三人行（主）
持续时间=时间。性能计数器（）-开始时间
打印（“花费了{.2f}秒”。格式（持续时间））

当我运行您的代码时，我得到：

  File "/tmp/zigb.py", line 12, in child
    await sender.send('Parent {0}, Child {1}: exiting!'.format(parent, i))
  File "/home/njs/.user-python3.7/lib/python3.7/site-packages/trio/_channel.py", line 157, in send
    self.send_nowait(value)
  File "/home/njs/.user-python3.7/lib/python3.7/site-packages/trio/_core/_ki.py", line 167, in wrapper
    return fn(*args, **kwargs)
  File "/home/njs/.user-python3.7/lib/python3.7/site-packages/trio/_channel.py", line 135, in send_nowait
    raise trio.ClosedResourceError
trio.ClosedResourceError

这里发生的事情是，您将

发送方

通道传递到所有10个子任务中，然后每个子任务都与发送方进行

异步：…

，这将关闭

发送方

通道。所以第一个任务使用它，然后关闭它，然后下一个任务尝试使用它。。。但是它已经关闭了，所以它得到了一个错误

幸运的是，Trio为这个问题提供了一个解决方案：您可以对内存通道对象使用

clone

方法来创建该内存通道的第二个副本，该副本的工作方式完全相同，但可以独立关闭。因此，诀窍是向每个孩子传递一个发送者的克隆，然后他们各自关闭克隆，然后一旦所有克隆都关闭，接收者就会收到通知并停止循环

文件：

代码的固定版本：

import trio
import asks
import time
import random

async def child(parent, i, sender, limit2):
    async with limit2:
        print('Parent {0}, Child {1}: started! Sleeping now...'.format(parent, i))
        #await trio.sleep(random.randrange(0, 3))
        print('Parent {0}, Child {1}: exiting!'.format(parent, i))
        async with sender:
            await sender.send('Parent {0}, Child {1}: exiting!'.format(parent, i))

async def parent(i, limit):
    async with limit:
        print('Parent {0}: started! Sleeping now...'.format(i))
        #await trio.sleep(random.randrange(0, 3))

        sender, receiver = trio.open_memory_channel(10)
        limit2 = trio.CapacityLimiter(2)
        async with trio.open_nursery() as nursery:
            for j in range(10):
                # CHANGED: Give each child its own clone of 'sender', which
                # it will close when it's done
                nursery.start_soon(child, i, j, sender.clone(), limit2)
        # CHANGED: Close the original 'sender', once we're done making clones
        await sender.aclose()

        async with receiver:
            async for value in receiver:
                print('Got value: {!r}'.format(value))
        print('Parent {0}: exiting!'.format(i))

async def main():
    limit = trio.CapacityLimiter(1)
    async with trio.open_nursery() as nursery:
        for i in range(1):
            nursery.start_soon(parent, i, limit)


if __name__ == "__main__":
    start_time = time.perf_counter()
    trio.run(main)
    duration = time.perf_counter() - start_time
    print("Took {:.2f} seconds".format(duration))

---

运行代码时会发生什么，它与您希望的有什么不同？它不是打印

print（'Parent{0}:exiting！'.format（i））

或退出程序。我认为这可能与

limit2=trio.CapacityLimiter（3）

有关，因为如果没有它，它就会像我预期的那样工作。但是我想在这里设置一个限制。这也是我尝试做的一些基本的事情，以便我以后可以开始使用python，所以我有一个类似于样板的东西，我为多个网站生成一个worker，然后为每个网站生成x个worker来做一些检查，然后返回该信息，并与我之前的信息合并已经。