[python] 다중 처리 : 프로세스간에 큰 읽기 전용 개체를 공유합니까?

다중 처리를 통해 생성 된 자식 프로세스 는 프로그램에서 이전 에 생성 된 객체를 공유 합니까?

때에 따라 다르지. 전역 읽기 전용 변수의 경우 (소비 된 메모리와는 별도로) 그렇게 간주 될 수 있습니다.

multiprocessing 의 문서에 따르면 다음과 같습니다.

Better to inherit than pickle/unpickle

Windows에서 다중 처리의 많은 유형은 하위 프로세스에서 사용할 수 있도록 선택 가능해야합니다. 그러나 일반적으로 파이프 나 큐를 사용하여 공유 객체를 다른 프로세스로 보내지 않아야합니다. 대신 다른 곳에서 생성 된 공유 리소스에 액세스해야하는 프로세스가 조상 프로세스에서 상속 할 수 있도록 프로그램을 정렬해야합니다.

Explicitly pass resources to child processes

Unix에서 하위 프로세스는 전역 리소스를 사용하여 상위 프로세스에서 생성 된 공유 리소스를 사용할 수 있습니다. 그러나 개체를 자식 프로세스의 생성자에 인수로 전달하는 것이 좋습니다.

코드를 (잠재적으로) Windows와 호환되도록 만드는 것 외에도 자식 프로세스가 여전히 활성 상태 인 한 개체가 부모 프로세스에서 가비지 수집되지 않습니다. 이는 상위 프로세스에서 개체가 가비지 수집 될 때 일부 리소스가 해제되는 경우 중요 할 수 있습니다.

Global variables

자식 프로세스에서 실행되는 코드가 전역 변수에 액세스하려고하면 표시되는 값 (있는 경우)이 Process.start ()가 호출 될 때 부모 프로세스의 값과 동일하지 않을 수 있습니다. .

예

Windows (단일 CPU) :

#!/usr/bin/env python
import os, sys, time
from multiprocessing import Pool

x = 23000 # replace `23` due to small integers share representation
z = []    # integers are immutable, let's try mutable object

def printx(y):
    global x
    if y == 3:
       x = -x
    z.append(y)
    print os.getpid(), x, id(x), z, id(z) 
    print y
    if len(sys.argv) == 2 and sys.argv[1] == "sleep":
       time.sleep(.1) # should make more apparant the effect

if __name__ == '__main__':
    pool = Pool(processes=4)
    pool.map(printx, (1,2,3,4))

와 함께 sleep:

$ python26 test_share.py sleep
2504 23000 11639492 [1] 10774408
1
2564 23000 11639492 [2] 10774408
2
2504 -23000 11639384 [1, 3] 10774408
3
4084 23000 11639492 [4] 10774408
4

없이 sleep:

$ python26 test_share.py
1148 23000 11639492 [1] 10774408
1
1148 23000 11639492 [1, 2] 10774408
2
1148 -23000 11639324 [1, 2, 3] 10774408
3
1148 -23000 11639324 [1, 2, 3, 4] 10774408
4

답변

import multiprocessing

x = 23

def printx(y):
    print x, id(x)
    print y

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    pool.map(printx, (1,2,3,4))

$ ./mtest.py
23 22995656
1
23 22995656
2
23 22995656
삼
23 22995656
4

import time
import multiprocessing

def load_data( queue_load, n_processes )

    ... load data here into some_variable

    """
    Store multiple copies of the data into
    the data queue. There needs to be enough
    copies available for each process to access.
    """

    for i in range(n_processes):
        queue_load.put(some_variable)


def work_with_data( queue_data, queue_load ):

    # Wait for load_data() to complete
    while queue_load.empty():
        time.sleep(1)

    some_variable = queue_load.get()

    """
    ! Tuples can also be used here
    if you have multiple data files
    you wish to keep seperate.
    a,b = queue_load.get()
    """

    ... do some stuff, resulting in new_data

    # store it in the queue
    queue_data.put(new_data)


def start_multiprocess():

    n_processes = 5

    processes = []
    stored_data = []

    # Create two Queues
    queue_load = multiprocessing.Queue()
    queue_data = multiprocessing.Queue()

    for i in range(n_processes):

        if i == 0:
            # Your big data file will be loaded here...
            p = multiprocessing.Process(target = load_data,
            args=(queue_load, n_processes))

            processes.append(p)
            p.start()

        # ... and then it will be used here with each process
        p = multiprocessing.Process(target = work_with_data,
        args=(queue_data, queue_load))

        processes.append(p)
        p.start()

    for i in range(n_processes)
        new_data = queue_data.get()
        stored_data.append(new_data)

    for p in processes:
        p.join()
    print(processes)