Question

我试图实现一个将在后台运行并执行任务的线程。这是我的代码，它给出了预期的输出。

代码1：

from time import sleep
from threading import Thread

class myTest( ):
    def myThread( self ):
        while True:
            sleep( 1 )
            print self.myList.keys( )
            if 'exit' in self.myList.keys( ):
                break
        return

    def __init__( self ):
        self.myList = { } 
        self.thread = Thread( target = self.myThread, args = (  ) )
        self.thread.start( )
        return

    def myFun( self ):
        i = 0
        while True:
            sleep( 0.5 )
            self.myList[ i ] = i
            i += 1
            if i > 5 :
                self.myList[ 'exit' ] = ''
                break
        return

x = myTest( )
x.myFun( )

输出1：

[0]
[0, 1, 2]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5, 'exit']

当我创建一个多进程环境并在新的子进程中创建此对象时，该线程无法访问公共内存，并且字符myList在该线程中保持空白。这是代码。

代码2：

from time import sleep
from threading import Thread
from multiprocessing import Process

class myTest( ):
    def myThread( self ):
        while True:
            sleep( 1 )
            print "myThread", self.myList.keys( )
            if 'exit' in self.myList.keys( ):
                break
        return

    def __init__( self ):
        self.myList = { } 
        self.thread = Thread( target = self.myThread, args = (  ) )
        self.thread.start( )
        self.i = 0
        return

    def myFun( self ):
        self.myList[ self.i ] = self.i
        self.i += 1
        if self.i > 5 :
            self.myList[ 'exit' ] = ''
            return 'exit'
        print 'myFun', self.myList.keys( )
        return

class myProcess( Process ):
    def __init__( self ):
        super( myProcess, self ).__init__( )
        self.myObject = myTest( )
        return

    def run(self):
        while True:
            sleep( 0.5 )
            x = self.myObject.myFun( )
            if x == 'exit':
                break
        return

x = myProcess( )
x.start( )

输出2：

myFun [0]
myThread []
myFun [0, 1]
myFun [0, 1, 2]
myThread []
myFun [0, 1, 2, 3]
myFun [0, 1, 2, 3, 4]
myThread []
myThread []
myThread []
... ... ...
... ... ...

在第一个代码中，对象是在Python进程内创建的（虽然是主进程）。在第二个代码中，对象是在Python的子进程中创建的，其中发生的一切都应该像第一个一样。

任何人都可以解释为什么在第二个代码中，线程无法使用父对象的共享内存？
我想要output 1中的code 2，即强制线程使用父对象的共享公共内存。我需要做出哪些修改？

Answer 1

当您生成第二个进程时，会创建第一个进程的副本，因此 在第二个进程中生成的线程只能访问该进程堆栈

在 code2 myTest的对象是在构造函数（__init__）中创建的，因此它不会与生成的进程共享相同的内存是run。只需将对象创建的位置从构造函数更改为run，创建的对象就会成为生成的进程内存的一部分。

Answer 2

分叉进程在fork()时刻看到父内存的快照。当父母或孩子改变一个位时，他们的记忆映射会发散，一个人看到它改变了什么，另一个人看到了旧的状态。我在这个答案中解释了这个理论更加冗长：https://stackoverflow.com/a/29838782/73957

如果要共享内存[更改]，则必须隐式执行。在Python中，一种简单的方法是multiprocessing.{Queue,Value,Array}，请参阅https://docs.python.org/2/library/multiprocessing.html#sharing-state-between-processes

在进程

2 个答案: