Общие сведения о многопроцессорности: управление общей памятью, блокировки и очереди в Python

Ответ 1

multiprocessing.Lock реализуется с использованием объекта Semaphore, предоставляемого ОС. В Linux ребенок просто наследует дескриптор семафора от родителя через os.fork. Это не копия семафора; он фактически наследует тот же дескриптор, который имеет родитель, так же, как и дескрипторы файла. Windows, с другой стороны, не поддерживает os.fork, поэтому он должен разжечь Lock. Это делается путем создания дублирующего дескриптора для Семафора Windows, используемого внутри объекта multiprocessing.Lock, с использованием API DuplicateHandle, который гласит:

Двойной дескриптор относится к тому же объекту, что и исходный дескриптор. Поэтому любые изменения объекта отражаются через оба ручки

API DuplicateHandle позволяет вам передать права на дублированный дескриптор дочернему процессу, чтобы дочерний процесс действительно мог использовать его после его разблокировки. Создав дублированный дескриптор, принадлежащий дочернему элементу, вы можете эффективно "делить" объект блокировки.

Здесь объект семафора в multiprocessing/synchronize.py

class SemLock(object):

    def __init__(self, kind, value, maxvalue):
        sl = self._semlock = _multiprocessing.SemLock(kind, value, maxvalue)
        debug('created semlock with handle %s' % sl.handle)
        self._make_methods()

        if sys.platform != 'win32':
            def _after_fork(obj):
                obj._semlock._after_fork()
            register_after_fork(self, _after_fork)

    def _make_methods(self):
        self.acquire = self._semlock.acquire
        self.release = self._semlock.release
        self.__enter__ = self._semlock.__enter__
        self.__exit__ = self._semlock.__exit__

    def __getstate__(self):  # This is called when you try to pickle the `Lock`.
        assert_spawning(self)
        sl = self._semlock
        return (Popen.duplicate_for_child(sl.handle), sl.kind, sl.maxvalue)

    def __setstate__(self, state): # This is called when unpickling a `Lock`
        self._semlock = _multiprocessing.SemLock._rebuild(*state)
        debug('recreated blocker with handle %r' % state[0])
        self._make_methods()

Обратите внимание на вызов assert_spawning в __getstate__, который вызывается при травлении объекта. Вот как это реализовано:

#
# Check that the current thread is spawning a child process
#

def assert_spawning(self):
    if not Popen.thread_is_spawning():
        raise RuntimeError(
            '%s objects should only be shared between processes'
            ' through inheritance' % type(self).__name__
            )

Эта функция гарантирует, что вы "наследуете" Lock, вызывая thread_is_spawning. В Linux этот метод просто возвращает False:

@staticmethod
def thread_is_spawning():
    return False

Это связано с тем, что Linux не нуждается в pickle для наследования Lock, поэтому, если __getstate__ фактически вызывается в Linux, мы не должны наследовать. В Windows больше происходит:

def dump(obj, file, protocol=None):
    ForkingPickler(file, protocol).dump(obj)

class Popen(object):
    '''
    Start a subprocess to run the code of a process object
    '''
    _tls = thread._local()

    def __init__(self, process_obj):
        ...
        # send information to child
        prep_data = get_preparation_data(process_obj._name)
        to_child = os.fdopen(wfd, 'wb')
        Popen._tls.process_handle = int(hp)
        try:
            dump(prep_data, to_child, HIGHEST_PROTOCOL)
            dump(process_obj, to_child, HIGHEST_PROTOCOL)
        finally:
            del Popen._tls.process_handle
            to_child.close()


    @staticmethod
    def thread_is_spawning():
        return getattr(Popen._tls, 'process_handle', None) is not None

Здесь thread_is_spawning возвращает True, если объект Popen._tls имеет атрибут process_handle. Мы видим, что атрибут process_handle создается в __init__, тогда данные, которые мы хотим унаследовать, передаются от родителя к дочернему с помощью dump, тогда атрибут удаляется. Таким образом, thread_is_spawning будет только True во время __init__. Согласно этот поток списков рассылки python-идей, на самом деле это искусственное ограничение, добавленное для моделирования того же поведения, что и os.fork в Linux. Windows фактически может поддерживать передачу Lock в любое время, потому что DuplicateHandle может быть запущен в любое время.

Все вышеизложенное относится к объекту Queue, потому что он использует Lock внутренне.

Я бы сказал, что наследование объектов Lock предпочтительнее использовать Manager.Lock(), потому что, когда вы используете Manager.Lock, каждый отдельный вызов, который вы делаете в Lock, должен быть отправлен через IPC в Manager процесс, который будет намного медленнее, чем использование общей Lock, которая живет внутри вызывающего процесса. Оба подхода являются вполне допустимыми.

Наконец, можно передать Lock всем членам Pool без использования Manager, используя аргументы ключевого слова initializer/initargs:

lock = None
def initialize_lock(l):
   global lock
   lock = l

def scenario_1_pool_no_manager(jobfunc, args, ncores):
    """Runs a pool of processes WITHOUT a Manager for the lock and queue.

    """
    lock = mp.Lock()
    mypool = mp.Pool(ncores, initializer=initialize_lock, initargs=(lock,))
    queue = mp.Queue()

    iterator = make_iterator(args, queue)

    mypool.imap(jobfunc, iterator) # Don't pass lock. It has to be used as a global in the child. (This means `jobfunc` would need to be re-written slightly.

    mypool.close()
    mypool.join()

return read_queue(queue)

Это работает, потому что аргументы, переданные в initargs, передаются методу __init__ объектов Process, которые выполняются внутри Pool, поэтому они в конечном итоге наследуются, а не маринуются.