Python Academy · Aula

Noções básicas de multiprocessing

Use vários núcleos de CPU

Noções básicas de multiprocessing é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Por que usar multiprocessamento

O GIL impede que linhas de execução executem código de bytes do Python em paralelo. O módulo multiprocessing contorna essa limitação ao iniciar processos separados, cada um com seu próprio interpretador e GIL, para que tarefas limitadas pela CPU realmente sejam executadas em vários núcleos.

import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())

Iniciando um processo

Process(target=func) reproduz a API de linhas de execução. Chame start() para iniciar e join() para aguardar.

import multiprocessing as mp

def worker():
    print('hello from a child process')

if __name__ == '__main__':
    p = mp.Process(target=worker)
    p.start()
    p.join()
    print('parent done')

A proteção de main

Em algumas plataformas, os processos filhos importam seu programa. Sem uma proteção if __name__ == '__main__':, você pode criar processos recursivamente. Sempre envolva o código de inicialização com ela.

import multiprocessing as mp

def task(n):
    print('processing', n)

if __name__ == '__main__':
    for i in range(3):
        p = mp.Process(target=task, args=(i,))
        p.start()
        p.join()

Passando argumentos

Use args para argumentos posicionais e kwargs para argumentos nomeados, assim como nas linhas de execução. Os argumentos são serializados e enviados ao processo filho.

import multiprocessing as mp

def show(label, times):
    for _ in range(times):
        print(label)

if __name__ == '__main__':
    p = mp.Process(target=show, args=('hi',), kwargs={'times': 2})
    p.start()
    p.join()

Um conjunto de trabalhadores

multiprocessing.Pool gerencia um grupo de processos. pool.map distribui um iterável entre eles e reúne os resultados na ordem.

import multiprocessing as mp

def square(n):
    return n * n

if __name__ == '__main__':
    with mp.Pool(processes=2) as pool:
        print(pool.map(square, range(6)))

ProcessPoolExecutor

A API concurrent.futures também oferece ProcessPoolExecutor, com a mesma interface submit/map que você viu para linhas de execução.

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

if __name__ == '__main__':
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(cube, range(5))))

Espaços de memória separados

Cada processo tem sua própria memória. Modificar uma variável global em um processo filho não altera a cópia do processo pai. Os dados precisam ser retornados ou compartilhados explicitamente.

import multiprocessing as mp

counter = 0

def bump():
    global counter
    counter += 100

if __name__ == '__main__':
    p = mp.Process(target=bump)
    p.start()
    p.join()
    print('parent counter still:', counter)

Obtendo os resultados

Como a memória não é compartilhada, retorne os resultados por meio de Pool.map, executores ou filas, em vez de modificar variáveis globais.

import multiprocessing as mp

def double(n):
    return n * 2

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        results = pool.map(double, [1, 2, 3, 4])
    print('results:', results)

apply_async para chamadas individuais

apply_async agenda uma chamada e retorna um identificador de resultado. Chame .get() para obter o valor.

import multiprocessing as mp

def add(a, b):
    return a + b

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        r = pool.apply_async(add, (3, 4))
        print(r.get())

Requisito de serialização

Os destinos e argumentos precisam ser serializáveis para atravessar o limite entre processos. Funções no nível superior funcionam; lambdas e funções locais geralmente não funcionam.

import multiprocessing as mp

def top_level(n):
    return n + 1

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        print(pool.map(top_level, [10, 20]))

Quando escolher processos

Use processos para tarefas limitadas pela CPU: cálculos matemáticos, processamento de imagens e análise. A sobrecarga de iniciar processos e serializar dados faz com que eles sejam mais adequados a poucas tarefas pesadas do que a muitas tarefas pequenas.

import multiprocessing as mp

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with mp.Pool() as pool:
        print(pool.map(heavy, [1000, 2000, 3000]))

Verificação rápida

Teste sua compreensão de multiprocessamento.

Recapitulação

Você aprendeu os conceitos básicos de multiprocessamento:

Os processos contornam o GIL para obter paralelismo real da CPU.
Use a proteção if __name__ == '__main__'.
Pool e ProcessPoolExecutor distribuem o trabalho e reúnem os resultados.
A memória não é compartilhada; os argumentos precisam ser serializáveis.

A seguir: compartilhamento seguro de dados com filas e bloqueios.

Perguntas Frequentes

A aula “Noções básicas de multiprocessing” é grátis?

Sim — o texto completo de “Noções básicas de multiprocessing” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Noções básicas de multiprocessing”?

Use vários núcleos de CPU Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Noções básicas de multiprocessing”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy