Многопроцессорность в Python | Параллельная обработка | Высокопроизводительное вычисление

Введение

Python multiprocessing - это мощный инструмент, который может значительно ускорить выполнение Python-программ, требующих высокой вычислительной мощности. В этом лабе вы узнаете о Python multiprocessing и о том, как использовать его для параллельного запуска процессов. Мы начнем с простых примеров и постепенно перейдем к более сложным.

Создание простой программы с многопроцессорностью

Первым шагом в изучении многопроцессорности в Python является создание простой программы, которая демонстрирует, как это работает. В этой программе мы создадим функцию, которая принимает один аргумент и возвращает квадрат этого числа. Затем мы используем многопроцессорность для запуска этой функции на нескольких процессах.

Пожалуйста, завершите square.py.

import multiprocessing

def square(x):
    return x * x

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = pool.map(square, range(10))
    print(results)

Этот код создает пул из четырех процессов и использует функцию map(), чтобы применить функцию square() к каждому из чисел в диапазоне от 0 до 9. Затем результаты выводятся в консоль.

Использование многопроцессорности для ускорения обработки

Теперь, когда вы понимаете, как работает многопроцессорность в Python, мы можем перейти к более сложному примеру. В этом примере мы будем использовать многопроцессорность для ускорения обработки большого списка чисел.

Пожалуйста, завершите complex_square.py.

import multiprocessing

def square(x):
    return x * x

if __name__ == '__main__':
    with multiprocessing.Pool(processes=4) as pool:
        results = pool.map(square, range(1000000))
    print(results[:10])

Этот код создает пул из четырех процессов и использует функцию map(), чтобы применить функцию square() к каждому из чисел в диапазоне от 0 до 999999. Строка with используется для обеспечения правильного закрытия пула процессов при завершении обработки. Затем выводятся первые десять результатов в консоль.

Обмен данными между процессами

В некоторых случаях при использовании многопроцессорности в Python может потребоваться обмен данными между процессами. В этом примере мы будем использовать функцию multiprocessing.Queue() для создания общих очередей между процессами.

Пожалуйста, завершите multiprocessing_queue.py.

import multiprocessing

def producer(queue):
    for i in range(10):
        queue.put(i)

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(item)

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    process_producer = multiprocessing.Process(target=producer, args=(queue,))
    process_consumer = multiprocessing.Process(target=consumer, args=(queue,))
    process_producer.start()
    process_consumer.start()
    process_producer.join()
    queue.put(None)
    process_consumer.join()

В этом коде с помощью функции multiprocessing.Queue() создается общая очередь queue. Затем создаются два процесса, каждый из которых вызывает функцию producer() и consumer(). Функция producer() помещает числа от 0 до 9 в очередь, а функция consumer() извлекает каждый элемент из очереди и выводит его в консоль.

Асинхронные задачи с использованием pool.apply_async()

Кроме map(), класс multiprocessing.Pool() предоставляет другой метод для параллельного запуска процессов, называемый apply_async(). Этот метод позволяет вам отправить вызов функции в пул процессов и немедленно продолжить выполнение, не ожидая результата. Вместо этого вы можете использовать обратный вызов (callback-функцию), чтобы получить результат вызова функции, когда он будет готов.

Пожалуйста, завершите slow_square.py.

import multiprocessing
import time

def slow_square(x):
    time.sleep(1)
    return x * x

def callback(result):
    print(result)

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = [pool.apply_async(slow_square, (x,), callback=callback) for x in range(10)]
    for result in results:
        result.wait()
    print("All tasks completed.")

В этом примере мы определяем функцию slow_square(), которая принимает число $x$, ждет одну секунду и затем возвращает квадрат $x$. Мы также определяем обратную вызов функцию callback(), которая просто выводит результат, когда он доступен.

Затем мы создаем пул из четырех процессов и используем apply_async(), чтобы отправить вызов функции в пул для каждого числа в диапазоне от 0 до 9. Мы передаем функцию slow_square() и аргумент $x$ с использованием параметра args, а также указываем обратную вызов функцию, которая должна быть вызвана, когда результат будет готов.

Затем мы перебираем список результатов и вызываем result.wait(), чтобы заблокировать главный поток, пока результат не будет готов. Наконец, мы выводим сообщение, указывающее, что все задачи завершены.

Резюме

В этом практическом занятии вы узнали, как использовать многопроцессорность в Python для параллельного запуска процессов. Вы начали с простой программы, которая демонстрировала, как работает многопроцессорность, а затем перешли к более сложным примерам, где использовалась многопроцессорность для ускорения обработки, разделения памяти между процессами и выполнения асинхронных задач с использованием apply_async(). В конце этого практического занятия вы должны хорошо понять, как использовать многопроцессорность в своих собственных программах на Python, чтобы достичь большей вычислительной мощности и эффективности, а также как обмениваться данными между процессами при необходимости.

Многопроцессорность в Python для параллельного выполнения