Question

假设我有三个模块：

mod1 mod2 mod3

在调用mod.launch（）时，它们每个都将无限运行。

有什么优雅的方法可以立即启动所有这些无限循环，而无需等待一个循环完成再调用另一个循环？

假设我有一种launcher.py，我会在其中尝试：

import mod1
import mod2
import mod3

if __name__ == "__main__":
    mod1.launch()
    mod2.launch()
    mod3.launch()

这显然不起作用，因为它将在启动mod2.launch（）之前等待mod1.launch（）完成。

感谢您提供任何帮助。

Answer 1

如果要并行执行多个功能，可以使用multiprocessing库或concurrent.futures.ProcessPoolExecutor。 ProcessPoolExecutor在内部使用多处理程序，但界面更简单。

Answer 2

根据每个任务所完成工作的性质，答案会有所不同。

如果每个任务大部分或全部与IO绑定，我建议使用多线程。

如果每个任务都受CPU限制，我建议进行多处理（由于python中的GIL）。

Answer 3

您还可以使用threading模块在一个单独的线程上运行每个模块，但是要在同一进程中进行：

import threading
import mod1
import mod2
import mod3

if __name__ == "__main__":
    # make a list of all modules we want to run, for convenience
    mods = [mod1, mod2, mod3] 
    # Prepare a thread for each module to run the `launch()` method
    threads = [threading.Thread(target=mod.launch) for mod in mods]
    # run all threads
    for thread in threads:
        thread.start()
    # wait for all threads to finish
    for thread in threads:
        thread.join()

multiprocess模块执行的任务非常相似，并且具有非常相似的API，但是使用单独的进程而不是线程，因此您也可以使用它。

Answer 4

我建议使用Ray，它是用于并行和分布式Python的库。与标准线程库和多处理库相比，它具有一些优势。

相同的代码将在单台计算机或多台计算机上运行。
您可以并行化函数和类。
使用共享内存在任务之间高效地共享对象。

为了提供一个简单的可运行示例，我将使用函数和类而不是模块，但是您始终可以将模块包装在函数或类中。

方法1：使用任务并行功能。

import ray
import time

ray.init()

@ray.remote
def mod1():
    time.sleep(3)

@ray.remote
def mod2():
    time.sleep(3)

@ray.remote
def mod3():
    time.sleep(3)

if __name__ == '__main__':
    # Start the tasks. These will run in parallel.
    result_id1 = mod1.remote()
    result_id2 = mod2.remote()
    result_id3 = mod3.remote()

    # Don't exit the interpreter before the tasks have finished.
    ray.get([result_id1, result_id2, result_id3])

方法2：使用演员进行平行的类。

import ray
import time

# Don't run this again if you've already run it.
ray.init()

@ray.remote
class Mod1(object):
    def run(self):
        time.sleep(3)

@ray.remote
class Mod2(object):
    def run(self):
        time.sleep(3)

@ray.remote
class Mod3(object):
    def run(self):
        time.sleep(3)

if __name__ == '__main__':
    # Create 3 actors.
    mod1 = Mod1.remote()
    mod2 = Mod2.remote()
    mod3 = Mod3.remote()

    # Start the methods, these will run in parallel.
    result_id1 = mod1.run.remote()
    result_id2 = mod2.run.remote()
    result_id3 = mod3.run.remote()

    # Don't exit the interpreter before the tasks have finished.
    ray.get([result_id1, result_id2, result_id3])

您可以看到Ray documentation。

从一个Python文件启动multilpe无限python进程

4 个答案: