Question

我在aRHEL 6.5 Linux主机上有一个在Python 3.5.1下运行的应用程序框架。这是一个非常简化的逻辑视图：

baseclass.py:

class base(object):
    v = None
    w = None

    def __init__(self, v):
        self.v = v
        return

    def a(self):
        self.w = perform_tasks(self.v)
        return

    def retw(self):
        return(self.w)

    def close(self):
        del(self.v)
        del(self.w)
        return

myotherclass.py:
import baseclass

class dostuff(object):
    bar = None
    b = None
    def __init__(self, b):
        self.bar = baseclass.base(b)
        return

    def fb(self):
        self.bar.a()
        do stuff
        self.b = self.bar.retw()
        bar.close()
        return

    def retb(self):
        return(self.b)

    def close(self):
        del(self.b)
        del(self.bar)
        return

app.py:
import multiprocessing as mp
import myotherclass

def client(conn):
    while True:
        foo = myotherclass.dostuff(conn.recv())
        foo.fb()
        baz = foo.retb()
        conn.send(baz)
        foo.close()
        del(foo)
    return

workers = []
for i in range(0, X):
    parent_conn, client_conn = mp.Pipe()
    worker = mp.Process(target=client, args=(client_conn))
    worker.start()
    workers.append([worker, parent_conn])

....
workers[0][1].send(somedata)
workers[1][1].send(somedata)

因此，当我启动app.py时，它会将X个子项作为单独的进程生成，并使用parent_conn和client_conn与它们进行通信。

然后它向孩子们发送命令告诉他们做一些工作。孩子们愉快地工作并返回结果。

但是，似乎所有的孩子都在共享同一个基类实例。我所看到的是：

儿童1和儿童2启动。 app.py向他们发送信号以开始处理。

Child 1创建了myotherclass.dostuff的实例。

Child 2创建了myotherclass.dostuff的实例。

Child 2在Child 1之前稍微完成，关闭myotherclass.dostuff的实例并删除它的引用，这会导致Child 2的dostuff实例关闭并删除它对baseclass的引用。

子级1立即失败，并抛出一个异常，即不允许引用NoneType。

对我来说，这不应该发生，因为Child 1和Child 2是完全独立的具有单独PID的进程。 baseclass和myotherclass没有任何可能导致争用的全局变量，他们需要的所有数据都本地存储在类中，如＃34; self。＆＃34;变量

为什么所有的孩子都要分享同一个班级的基本实例？

Python 3多处理似乎共享资源

0 个答案: