Python Mul­ti­pro­ces­sing: Pro­ces­sa­mento paralelo de processos

Ao utilizar o Python multiprocessing, você poderá dividir cargas de trabalho entre vários processos, reduzindo o tempo total de execução. Ele é es­pe­ci­al­mente vantajoso para a re­a­li­za­ção de cálculos in­ten­si­vos e para lidar com grandes volumes de dados.

O que é Python mul­ti­pro­ces­sing?

O multiprocessing em Python pos­si­bi­lita a execução de vários processos si­mul­ta­ne­a­mente, para se obter o máximo de­sem­pe­nho de sistemas mul­ti­nú­cleo. Ao contrário de abor­da­gens de um único thread, nas quais tarefas são exe­cu­ta­das se­quen­ci­al­mente, o mul­ti­pro­ces­sa­mento do Python permite que di­fe­ren­tes partes de um programa funcionem pa­ra­le­la­mente e de forma in­de­pen­dente. Cada processo ganha sua própria área de memória e pode ser executado em núcleos separados, o que reduz sig­ni­fi­ca­ti­va­mente o tempo de execução de operações com­pu­ta­ci­o­nal­mente in­ten­si­vas ou de críticas em termos de tempo.

As apli­ca­ções do Python multiprocessing são variadas. Em ma­ni­pu­la­ções e análises de dados, o multiprocessing é ge­ral­mente utilizado para processar grandes conjuntos de dados mais ra­pi­da­mente e acelerar análises complexas. Em si­mu­la­ções e cálculos de modelagem, como em apli­ca­ções ci­en­tí­fi­cas, o multiprocessing pode ser empregado para diminuir o tempo de execução de cálculos complexos. Ele também pode ser usado no web scraping para coletar dados de várias páginas web si­mul­ta­ne­a­mente, e na visão com­pu­ta­ci­o­nal e no pro­ces­sa­men­tos de imagem, para melhorar a efi­ci­ên­cia das operações de análise.

Pos­si­bi­li­da­des do Python mul­ti­pro­ces­sing

A linguagem de pro­gra­ma­ção Python permite que o multiprocessing seja im­ple­men­tado de várias formas. Abaixo, apre­sen­ta­mos as três mais comuns: o módulo multiprocessing, a bi­bli­o­teca concurrent.futures e o pacote joblib.

Módulo multiprocessing

O módulo multiprocessing é o módulo padrão do Python multiprocessing. Ele permite a criação de processos, a troca de dados entre processos e a sin­cro­ni­za­ção por meio de travas, filas e outros me­ca­nis­mos. Observe:

import multiprocessing
def task(n):
    result = n * n
    print(f"Result: {result}")
if __name__ == "__main__":
    processes = []
    for i in range(1, 6):
        process = multiprocessing.Process(target=task, args=(i,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()

No exemplo acima, estamos usando a classe multiprocessing.Process para criar e iniciar processos que executam a função task() — essa função calcula o quadrado do número definido como argumento. Os processos são ini­ci­a­li­za­dos e aguar­da­mos a conclusão deles antes que o programa principal continue. O resultado é exibido na forma de f-string, método de for­ma­ta­ção de strings em Python que combina ex­pres­sões. A ordem de execução dos processos é aleatória e não de­ter­mi­nís­tica.

Também é possível criar um pool de processos com o Python multiprocessing:

import multiprocessing
def task(n):
    return n * n
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(task, range(1, 6))
        print(results)  # Output: [1, 4, 9, 16, 25]

Com pool.map(), a função task() é aplicada a uma sequência de dados, e os re­sul­ta­dos são coletados e exibidos.

Bi­bli­o­teca concurrent.futures

Esse módulo fornece uma interface de alto nível para execuções as­sín­cro­nas e pro­ces­sa­men­tos paralelos de processos. Ele utiliza o Pool Executor para executar tarefas em um pool de processos ou threads. O módulo concurrent.futures oferece uma maneira mais simples de lidar com tarefas as­sín­cro­nas e, em muitos casos, é mais fácil de usar do que o módulo Python multiprocessing.

import concurrent.futures
def task(n):
    return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
    futures = [executor.submit(task, i) for i in range(1, 6)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result()) # result in random order

O código utiliza o módulo concurrent.futures para processar tarefas em paralelo, por meio do ProcessPoolExecutor. Nele, a função task(n) é chamada para números de 1 a 5. O método as_completed() espera a conclusão das tarefas e imprime os re­sul­ta­dos em qualquer ordem.

joblib

joblib é uma bi­bli­o­teca externa do Python. Ela foi de­sen­vol­vida para sim­pli­fi­car o pro­ces­sa­mento paralelo, es­pe­ci­al­mente útil em tarefas re­pe­ti­ti­vas, como na execução de funções com di­fe­ren­tes pa­râ­me­tros de entrada ou em trabalhos com grandes volumes de dados. As prin­ci­pais funções da bi­bli­o­teca joblib incluem a pa­ra­le­li­za­ção de tarefas, o ar­ma­ze­na­mento em cache dos re­sul­ta­dos das funções e a oti­mi­za­ção dos recursos de memória e com­pu­ta­ção.

from joblib import Parallel, delayed
def task(n):
    return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: Results of the function for numbers from 1 to 10

A expressão Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) inicia a execução paralela da função task() para os números de 1 a 10. O Parallel é con­fi­gu­rado com n_jobs=4, per­mi­tindo que até quatro jobs sejam pro­ces­sa­dos si­mul­ta­ne­a­mente. O chamado delayed(task)(i) cria a tarefa a ser executada em paralelo para cada número i no intervalo de 1 a 10 — isso significa que a função task() será chamada si­mul­ta­ne­a­mente para cada um desses números. Os re­sul­ta­dos para os números de 1 a 10 são ar­ma­ze­na­dos em results e depois exibidos.