O multiprocessing em Python é uma ferramenta poderosa que pode acelerar significativamente a execução de programas Python que exigem alta capacidade de processamento. Neste laboratório, você aprenderá sobre multiprocessing em Python e como usá-lo para executar processos em paralelo. Começaremos com exemplos simples e, gradualmente, avançaremos para exemplos mais complexos.
O primeiro passo para aprender sobre multiprocessing em Python é criar um programa simples que demonstre como ele funciona. Neste programa, criaremos uma função que recebe um único argumento e retorna o quadrado desse número. Em seguida, usaremos multiprocessing para executar essa função em múltiplos processos.
Por favor, complete 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)Este código cria um pool de quatro processos e usa a função map() para aplicar a função square() a cada um dos números no intervalo de 0 a 9. Os resultados são então impressos no console.
Agora que você entende como o multiprocessing funciona em Python, podemos passar para um exemplo mais complexo. Neste exemplo, usaremos multiprocessing para acelerar o processamento de uma grande lista de números.
Por favor, complete 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])Este código cria um pool de quatro processos e usa a função map() para aplicar a função square() a cada um dos números no intervalo de 0 a 999999. A instrução with é usada para garantir que o pool de processos seja devidamente fechado quando o processamento estiver completo. Os primeiros dez resultados são então impressos no console.
Em alguns casos, você pode precisar se comunicar entre processos ao usar multiprocessing em Python. Neste exemplo, usaremos a função multiprocessing.Queue() para criar uma fila compartilhada entre processos.
Por favor, complete 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()Este código cria uma fila compartilhada queue usando a função multiprocessing.Queue(). Em seguida, criamos dois processos que chamam cada um uma função producer() e consumer(). A função producer() coloca os números de 0 a 9 na fila, enquanto a função consumer() obtém cada item da fila e o imprime no console.
Além de map(), a classe multiprocessing.Pool() fornece outro método para executar processos em paralelo chamado apply_async(). Este método permite que você envie uma chamada de função para um pool de processos e continue a execução imediatamente sem esperar pelo resultado. Em vez disso, você pode usar uma função de callback para recuperar o resultado da chamada da função quando estiver pronto.
Por favor, complete 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.")Neste exemplo, definimos uma função slow_square() que recebe um número x, espera por um segundo e, em seguida, retorna o quadrado de x. Também definimos uma função de callback callback() que simplesmente imprime o resultado quando ele está disponível.
Em seguida, criamos um pool de quatro processos e usamos apply_async() para enviar uma chamada de função para o pool para cada número no intervalo de 0 a 9. Passamos a função slow_square() e o argumento x usando o parâmetro args, e também especificamos a função de callback a ser chamada quando o resultado estiver pronto.
Em seguida, percorremos a lista de resultados e chamamos result.wait() para bloquear a thread principal até que o resultado esteja pronto. Finalmente, imprimimos uma mensagem para indicar que todas as tarefas foram concluídas.
Neste laboratório, você aprendeu como usar o multiprocessing do Python para executar processos em paralelo. Você começou com um programa simples que demonstrou como o multiprocessing funciona e, em seguida, passou para exemplos mais complexos que usaram multiprocessing para acelerar o processamento e compartilhar memória entre processos e realizar tarefas assíncronas usando apply_async(). Ao final deste laboratório, você deve ter uma boa compreensão de como usar o multiprocessing em seus próprios programas Python para obter maior poder de processamento e eficiência, e para se comunicar entre processos quando necessário.
