Получение возвращаемого значения от функции в multiprocessing.Process

Быстрый ответ

Для получения результата работы функции, запущенной в отдельном процессе, используется объект multiprocessing.Queue:

from multiprocessing import Process, Queue

def worker(arg, q):
    q.put(arg * 2)

if __name__ == '__main__':
    q = Queue()
    p = Process(target=worker, args=(5, q))
    p.start()
    p.join()
    print(f"Результат: {q.get()}")

Основные моменты:

• Queue гарантирует обмен данными между процессами.
• Функция-работник помещает результат своей работы в Queue.
• Главный процесс ожидает окончания работы дочернего процесса с помощью join().
• После завершения работы дочернего процесса извлекаются данные с помощью q.get().

Продвинутые приемы и рекомендации

Применение multiprocessing.Manager()

• Этот подход позволяет превратить индивидуальные задачи в командную работу:

from multiprocessing import Process, Manager

def worker(return_dict, arg):
    return_dict[arg] = arg * 2

if __name__ == '__main__':
    with Manager() as manager:
        return_dict = manager.dict()
        processes = [Process(target=worker, args=(return_dict, i)) for i in range(5)]
        for p in processes:
            p.start()
        for p in processes:
            p.join()
        print(list(return_dict.values()))

Обдумывая код:

• Словари Manager — это удобная форма управления данными, обрабатываемыми несколькими процессами.
• Для получения результатов используется return_dict.values() после выполнения всех join().

Взаимодействие с multiprocessing.Pool

Pool облегчает параллельную обработку задач и сбор результатов:

from multiprocessing import Pool

def worker(arg):
    return arg * 2

if __name__ == '__main__':
    with Pool(5) as p:
        results = p.map(worker, range(5))
        print(results)

Преимущества:

• Минимальность кода, простота и удобство использования.
• Эффективное переиспользование процессов.

Обработка ошибок в коде

Использование блоков try-except помогает управлять исключениями:

def worker(arg, q):
    try:
        # В этом месте может произойти ошибка
        raise ValueError('Пример ошибки')
    except Exception as e:
        q.put(e)

if __name__ == '__main__':
    q = Queue()
    p = Process(target=worker, args=(5, q))
    p.start()
    p.join()
    result = q.get()
    if isinstance(result, Exception):
        print(f"Произошла ошибка: {result}")
    else:
        print(f"Результат: {result}")

Визуализация

Можно представить процесс получения значения из multiprocessing.Process как процесс получения письма из почтового ящика:

1. Вы создаете "почтовый ящик" (очередь).
2. "Почтальон" (процесс) начинает выполнение работы.
3. Почтальон оставляет письмо (результат) в ящике.
4. Вы забираете письмо (извлекаете результат).

Такой подход наглядно демонстрирует взаимодействие между родительским и дочерним процессами.

Углубляемся: альтернативные подходы и сложные нюансы

Использование multiprocessing.Pipe

multiprocessing.Pipe отлично подходит, когда требуется быстрая точечная связь:

from multiprocessing import Process, Pipe

def worker(conn):
    conn.send('Работа выполнена!')
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=worker, args=(child_conn,))
    p.start()
    p.join()
    print(parent_conn.recv())

Ключевые моменты:

• Эффективное использование ресурсов.
• Подходит для связи типа "точка-точка".

Обеспечение корректного завершения процессов

Правильное завершение процессов гарантирует сохранность ресурсов:

p.terminate()  # Принудительное завершение процесса.
p.join()  # Убедитесь, что процесс завершился корректно.

Правило:

• Используйте terminate, осознавая все риски.

Философия параллельных вычислений

Важно понимать компромиссы при использовании multiprocessing и выбирать между общим состоянием и изолированными функциями.

Обдумывая код:

• Изолированные функции упрощают параллелизм.
• Общее изменяемое состояние может вызвать проблемы согласования.

Полезные материалы

1. multiprocessing — основанная на процессах параллелизация — Документация Python 3.12.2 — полная документация по модулю multiprocessing.
2. Учебник по многопоточности в Python — видеоуроки по многопоточности.
3. Многопроцессорность в Python и возвращение результатов – статья о многопроцессорности и возвращении результатов.
4. Легкая параллельная разработка на python с concurrent.futures – примеры работы с многопоточностью на GitHub.
5. concurrent.futures — запуск параллельных задач — Документация Python 3.12.2 — альтернатива модулю multiprocessing.
6. Основы многопроцессорности в Python — PyMOTW 3 — введение в модуль multiprocessing в Python.