Python 多处理池无限期地创建和终止进程

编辑 下面这段简短的代码引发了同样的问题

# top_level.py
import to_import

if __name__ == '__main__':
    # This does not work
    t = to_import.Test()
    from pprint import pprint
    pprint(t.test())

结束编辑

双重编辑

有趣的是，当从我的命令提示符下运行时，这段代码工作正常，而不是我以前在Spyder中运行它的方式

编辑结束

我有一个类Tin，它将3d曲面存储为一系列点和三角形，并可以在该曲面上生成点的规则网格。当多重处理标志为False时，创建这些点的过程可以正常工作

但是，对于大型曲面上非常密集的网格，此过程可能非常缓慢，因此我实现了多处理以加快速度

# tin.py

from time import time
import multiprocessing as mp

def _points_from_face(points, grid_size):
    create 3d points within triangle on grid, uses other functions withinin this module

def _multiprocess_function(function, vals_gen, pool_size):
    with mp.Pool(processes=pool_size) as pool:
        results = pool.starmap(func=function,
                               iterable=vals_gen)
    return results

class Tin:
    def __init__(self, name, surface_dict):
        self.name = name
        self.points = surface_dict['Points']
        self.faces = dict(enumerate(surface_dict['Faces']))

    def generate_regular_grid(self, grid_size,
                              multiprocess=False,
                              pool_size=(mp.cpu_count()//2)):
        return_grid = dict()
        if pool_size < 1:
            multiprocess = False
        if multiprocess:
            faces_tuple = tuple(self.faces.values())
            vals_tuple = tuple((tuple(self.points[pid] for pid in face), grid_size)
                               for face in faces_tuple)
            results = _multiprocess_function(_points_from_face,
                                             vals_tuple,
                                             pool_size)
            for result in results:
                return_grid.update(result)
        else:
            for face in self.faces.values():
                points = tuple(self.points[pid] for pid in face)
                return_grid.update(_points_from_face(points, grid_size))
        return return_grid

我是否需要将所有内容都保存在一个长脚本中，或者是否有一种方法可以在导入的脚本中使用多处理

---

此外，landxml.py将被导入另一个文件本身，这是否可能再次导致相同的问题？

我不太清楚为什么这些进程会“立即消失”，但我确实怀疑在这种情况下，多处理是否真的对您有益。如果所有进程/线程的任务都是更新相同的共享数据结构，那么它们最终只会被序列化。。。基本上，运行速度比单线程版本慢，因为它们确实无法“同时”有意义地更新共享数据结构。@mike robinson points from face返回x，y对到z值的dict，这是计算密集型部分。通过对6个核进行多处理，一项耗时90秒的任务被减少到50秒，因此这无疑是有益的。

# tin.py

from time import time
import multiprocessing as mp

def _points_from_face(points, grid_size):
    create 3d points within triangle on grid, uses other functions withinin this module

def _multiprocess_function(function, vals_gen, pool_size):
    with mp.Pool(processes=pool_size) as pool:
        results = pool.starmap(func=function,
                               iterable=vals_gen)
    return results

class Tin:
    def __init__(self, name, surface_dict):
        self.name = name
        self.points = surface_dict['Points']
        self.faces = dict(enumerate(surface_dict['Faces']))

    def generate_regular_grid(self, grid_size,
                              multiprocess=False,
                              pool_size=(mp.cpu_count()//2)):
        return_grid = dict()
        if pool_size < 1:
            multiprocess = False
        if multiprocess:
            faces_tuple = tuple(self.faces.values())
            vals_tuple = tuple((tuple(self.points[pid] for pid in face), grid_size)
                               for face in faces_tuple)
            results = _multiprocess_function(_points_from_face,
                                             vals_tuple,
                                             pool_size)
            for result in results:
                return_grid.update(result)
        else:
            for face in self.faces.values():
                points = tuple(self.points[pid] for pid in face)
                return_grid.update(_points_from_face(points, grid_size))
        return return_grid

# landxml.py

from time import time
from tin import Tin

def parse_landxml(xml_path: str, print_times=False) -> Tin:
    read xml file and return Tin contained within

if __name__ == '__main__':
    st = time()
    surface = parse_landxml('some_tin.xml',
                             print_times=True)
    grid = surface.generate_regular_grid(grid_size=2,
                                         print_times=True,
                                         multiprocess=True)