Execute um processamento paralelo em Python

1. Use o pool de processamento e seus métodos para realizar multiprocessamento em Python
2. Use a função apply_async() para realizar multiprocessamento em Python
3. Use as funções map() e map_sync() para realizar multiprocessamento em Python

Este artigo explica como executar vários processos em paralelo em Python.

Use o pool de processamento e seus métodos para realizar multiprocessamento em Python

Para realizar multiprocessamento em Python, execute as seguintes etapas.

• Primeiro, importe o módulo multiprocessing.
• Use a classe Pool para definir o Python Processing Pool. Este pool representa um pool de processos de trabalho. Pegue o trecho de código abaixo como exemplo.

Pool(processes=n)

Consequentemente, a classe Pool permitirá que o número n de processos seja executado simultaneamente. Esta classe contém métodos que permitem a delegação de tarefas aos processos de trabalho do Pool.

A seguir estão alguns dos métodos da classe Pool.

• Pool.map() - Use este método de bloqueio do Pool para bloquear até que o resultado esteja pronto. Este método divide o iterável associado em vários blocos. Em seguida, ele envia os fragmentos ao pool de processos como tarefas separadas.

• Use os seguintes métodos não bloqueadores da classe Pool para enviar os processos simultaneamente de uma vez. Use o método get() para obter os resultados da função.

• Pool.apply_async()

• Pool.map_async()

Para determinar o número de processos que sua máquina pode manipular para multiprocessamento, você deve saber o número de processadores que possui em seu dispositivo; você pode verificar isso usando o código a seguir.

import multiprocessing as mp

print("Number of processors: ", mp.cpu_count())

Resultado:

Number of processors:  4

Use a função apply_async() para realizar multiprocessamento em Python

Aqui está um exemplo que demonstra o multiprocessamento usando o pool de processamento em Python enquanto determina o quadrado de um intervalo em números de 0 a 9.

Observe que aqui, imprimimos até o nome do trabalhador do processo, que é opcional.

from multiprocessing import Pool
from multiprocessing import Process, current_process
import time
from time import sleep
import random


def fnc_square(x):
    print(current_process().name)
    return x * x


if __name__ == "__main__":
    pool = Pool(processes=4)
    result = pool.apply_async(fnc_square, [6])
    print(result.get(timeout=1))
    print(pool.map(fnc_square, range(10)))

Resultado:

SpawnPoolWorker-1
36
SpawnPoolWorker-2
SpawnPoolWorker-1
SpawnPoolWorker-2
SpawnPoolWorker-1
SpawnPoolWorker-2
SpawnPoolWorker-1
SpawnPoolWorker-2
SpawnPoolWorker-1
SpawnPoolWorker-2
SpawnPoolWorker-1
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Use as funções map() e map_sync() para realizar multiprocessamento em Python

A função map_async não bloqueia, enquanto a função map bloqueia. Abaixo está um exemplo que demonstra a diferença entre esses dois comandos.

from multiprocessing import Pool
import time


def f(x):
    print(x * x)


if __name__ == "__main__":
    pool = Pool(processes=1)
    pool.map(f, range(10))
    r = pool.map_async(f, range(10))
    print("First print")
    print("Second print")
    r.wait()
    print("Third print")

Aqui, podemos observar que a função pool.map() aguardará a conclusão das 10 chamadas de operação. Portanto, vemos o resultado impresso em ordem.

Além disso, pool.map_async() executará as 10 chamadas de função de forma assíncrona. Quando a função r.wait() é chamada, ela bloqueia o processador para execução. Portanto, na saída, vemos as mensagens de impressão como First print e Second print no meio, mas a Third print estará sempre no final.

Resultado:

0
1
4
9
16
25
36
49
64
81
First print
Second print
0
1
4
9
16
25
36
49
64
81
Third print