Formas de Criar Processos

Diferença entre Síncrono e Assíncrono

from multiprocessing import Process
import time

def executar_tarefa(identificador):
    print(f'Tarefa iniciada: {identificador}')
    time.sleep(2)
    print(f'Tarefa finalizada: {identificador}')

if __name__ == '__main__':
    processo = Process(target=executar_tarefa, args=('P1',))
    processo.start()  # Execução assíncrona
    print('Processo principal continua')
    time.sleep(1)
    # executar_tarefa('P1')  # Execução síncrona

• Síncrono: Execução sequencial, tarefa deve concluir antes da continuação
• Assíncrono: Execução paralela, processo principal contiuna imediatamente

Mecanismo de Criação de Processos

• Windows: Cria processos através de importação de módulos
• Linux/Mac: Utiliza método de cópia de memória

Alternativa de Criação por Herança

class ProcessoPersonalizado(Process):
    def __init__(self, id, tempo):
        super().__init__()
        self.id = id
        self.tempo = tempo
        
    def run(self):
        print(f'Processo {self.id} iniciado')
        time.sleep(self.tempo)
        print(f'Processo {self.id} finalizado')

if __name__ == '__main__':
    p = ProcessoPersonalizado('A', 2)
    p.start()

Concorrência em Servidor TCP com Múltiplos Processos

import socket
from multiprocessing import Process

def iniciar_servidor():
    servidor = socket.socket()
    servidor.bind(('localhost', 8080))
    servidor.listen(5)
    return servidor

def lidar_conexao(conexao):
    while True:
        dados = conexao.recv(1024)
        conexao.send(dados.upper())

if __name__ == '__main__':
    servidor = iniciar_servidor()
    while True:
        conexao, _ = servidor.accept()
        Process(target=lidar_conexao, args=(conexao,)).start()

Método Join para Sincronização

def tarefa(duracao):
    time.sleep(duracao)

p1 = Process(target=tarefa, args=(1,))
p2 = Process(target=tarefa, args=(2,))

p1.start()
p2.start()

# Modelo 1: Espera sequencial
p1.join()  # Aguarda conclusão do p1
p2.join()  # Aguarda conclusão do p2

# Modelo 2: Espera paralela
p1.start()
p2.start()
p1.join()
p2.join()

Isolamento de Dados entre Processos

valor = 100

def modificar():
    global valor
    valor = 200

p = Process(target=modificar)
p.start()
p.join()
print(valor)  # Permanece 100 (alteração não compartilhada)

Comunicação entre Processos (IPC)

Utilização de Filas de Mensagens

from multiprocessing import Queue

fila = Queue(2)
fila.put('dado1')
fila.put('dado2')
print(fila.get())  # dado1

Modelo Produtor-Consumidor

def produtor(fila):
    fila.put('Mensagem')

def consumidor(fila):
    print(fila.get())

fila = Queue()
Process(target=produtor, args=(fila,)).start()
Process(target=consumidor, args=(fila,)).start()

Operações Adicionais com Processos

p = Process(target=...)
p.start()

# Identificação
print(p.pid)  
print(os.getpid())

# Controle
p.terminate()  # Finalização forçada
print(p.is_alive())  # Verificação de estado

# Processos daemon
p.daemon = True  # Termina com o processo principal

Processos Zumbis e Órfãos

• Procsesos Zumbis: Mantêm registros após término
• Processos Órfãos: Adotados pelo sistema quando o pai termina inesperadamente