事件驱动的线程创建
我一直在尝试各种解决以下问题的方法；无济于事。
我有大量的（python）模块/脚本和一个杰出的脚本 K.py 。
当 K.py 执行时，它会生成一些信息，例如国家/地区名称。现在，在其他模块（数百个）中，将有一些模块可以使用 K.py 生成的信息（在本例中为国家/地区名称）作为输入传递给它们来执行。递归地，上面的每个模块都会生成一些信息（城镇名称、街道号码等），这些信息可以作为其他模块的输入，等等。 这当然会产生执行脚本的二叉树。
需要注意的事项。
- 上面的模块/脚本（数百个）可以独立运行（它们不以任何方式相互依赖）
当所有模块完成执行时我应该能够做出结论（正在运行的 K.py 必须阻塞，直到执行模块的触发二叉树是“已连接”）。
如果，对于每个信息 I 和可运行脚本 S（即，S 可以以 I 作为输入运行），我决定创建一个新的线程，我最终可能会得到指数数量的线程（不是？）
我如何使用 python 线程（任何API）来“安全”地实施解决方案？ （伪代码？）
提前感谢您的智慧。
I have been trying all kinds of solution to the following problem; to no avail.
I have a large number of (python) modules/scripts and a distinguished script, K.py .
When K.py is executed, it generates some information, say a country name. Now, amongst the other modules (hundreds) there will be modules that can be executed with the information (country name, for this example) generated by K.py passed to them as input. Recursively, each of the modules above will generate some information (town names, street numbers, etc.), that can serve as input for other modules, and so on ..
This will of course result in a binary tree of scripts executed ..
Points to note.
- the modules/scripts (hundreds) above may run independently (they don't inter-depend in any way whatsoever)
I should be able to put a verdict when all modules have finished execution (that's running K.py must block until the triggered binary tree of excecuting modules is 'joined').
If, for each info I, and runnable script S (that is, S may run with I as input), I decide to create a new, thread, I might end up with an exponential number of threads (No ?)
How can I use python threads (any of the APIs) to 'safely' implement a solution ? (pseudo_code ?)
Thanks in advance for your wisdom.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（1）
解决这个问题的通常方法是创建一个工作队列并将单个作业存储在那里。因此，您需要某种应该由一个线程完成的工作的编程表示。
如果你有的话，你可以使用 多处理包 提供“线程“池（参见16.3.1.5。）和一个多线程队列来存储作业。
现在，每个进程从队列中取出一项作业，执行它 - 可能会向队列中添加新作业 - 当它完成时，执行下一个作业。当队列为空时，您就完成了。
请注意，这使用了多处理包，因为至少在带有 GIL 的 CPython 中，多线程 python 程序仅在大量 IO 或其他阻塞活动的情况下才有优势。
The usual way to solve this is to create a worker queue and store the single jobs there. So you need some kind of programatical representation of the work that should be done by one thread.
If you have that you can use the multiprocessing package that offers a "thread" pool (see 16.3.1.5.) and a multithreaded queue to store the jobs.
Now every process takes one job from the queue, executes it - maybe adds new jobs to the queue - and when it finishes takes the next one. You're finished when the queue is empty.
Note that this uses the multiprocessing package, because at least in CPython with the GIL a multithreaded python program is only advantageous in case of large IO or other blocking activities.