import threading
def funcao1():
for _ in range(5):
print("Função 1")
def funcao2():
for _ in range(5):
print("Função 2")
# Crie duas threads
thread1 = threading.Thread(target=funcao1)
thread2 = threading.Thread(target=funcao2)
# Inicie as threads
thread1.start()
thread2.start()
# Aguard até que ambas as threads terminem
thread1.join()
thread2.join()
print("Programa principal concluído")
O Lock (Trava, em tradução livre) é uma estrutura de sincronização usada em programação concorrente para evitar condições de corrida. Uma condição de corrida ocorre quando múltiplos threads tentam acessar ou modificar recursos compartilhados ao mesmo tempo, o que pode levar a resultados inesperados e indesejados. O Lock é uma maneira de coordenar o acesso a esses recursos compartilhados, permitindo que apenas um thread por vez entre na "seção crítica", onde a manipulação dos dados compartilhados ocorre.
OBS MELHOR USAR O RLOCK QUE NAO TRAVA O RECURSO
import threading
# Criando um objeto Lock
lock = threading.Lock()
# Variável compartilhada
contador = 0
# Função que será executada pelos threads
def incrementar():
global contador
# Adquirir o Lock
lock.acquire()
try:
for _ in range(1000000):
contador += 1
finally:
# Liberar o Lock, mesmo em caso de exceção
lock.release()
# Criando dois threads
thread1 = threading.Thread(target=incrementar)
thread2 = threading.Thread(target=incrementar)
# Iniciando os threads
thread1.start()
thread2.start()
# Aguardando os threads terminarem
thread1.join()
thread2.join()
# Imprimindo o valor final da variável compartilhada
print("Valor final do contador:", contador)
USANDO RLOCK SE UMA THEAD PRECISA BLOQUEAR QUE OUTRA THREAD USE O RECURSO EXEMPLO ENQUANDO UMA TA MODOFICANDO UM VALOR E A OUTRA THREAD VAI FAZER OUTRA OPERACAO ISSO PODE DAR PROBLEMA
import threading
# Criando um objeto RLock
lock = threading.RLock()
def funcao_com_lock():
with lock:
print("Bloqueado pela primeira vez")
with lock:
print("Bloqueado pela segunda vez")
# Criando duas threads que chamam a função_com_lock
thread1 = threading.Thread(target=funcao_com_lock)
thread2 = threading.Thread(target=funcao_com_lock)
# Iniciando as threads
thread1.start()
thread2.start()
# Esperando que ambas as threads terminem
thread1.join()
thread2.join()
print("Programa finalizado")
Multiprocessing
import queue
import multiprocessing
def tarefa(num):
# Realiza uma tarefa
print(f"Processo {num}: Tarefa realizada")
def main():
# Cria uma fila
q = queue.Queue()
# Cria os processos
processos = []
for i in range(5):
processos.append(multiprocessing.Process(target=tarefa, args=(i,)))
# Inicia os processos
for processo in processos:
processo.start()
# Adiciona tarefas à fila
for i in range(5):
q.put(i)
# Espera que os processos terminem
for processo in processos:
processo.join()
if __name__ == "__main__":
main()
MULTIPROCESSING USANDO PIPE (NAO RECOMENDADO)
import multiprocessing
def producer(pipe):
for i in range(10):
pipe.send(i)
def consumer(pipe):
while True:
data = pipe.recv()
if data is None:
break
print(data)
if __name__ == '__main__':
parent_conn, child_conn = multiprocessing.Pipe()
p = multiprocessing.Process(target=producer, args=(child_conn,))
c = multiprocessing.Process(target=consumer, args=(parent_conn,))
p.start()
c.start()
p.join()
c.join()
# Close the pipe to indicate that there are no more messages to send.
parent_conn.close()
USANDO CTYPES (BIBLIOTECA C )
eh possivel compartilhar dados de processos distintos
import multiprocessing
import ctypes
# Definir uma estrutura de dados C que será compartilhada entre os processos
class Info(ctypes.Structure):
_fields_ = [("nome", ctypes.c_char_p), ("idade", ctypes.c_int)]
def producer(pipe):
# Criar uma instância da estrutura de dados C
info = Info()
info.nome = "Bard"
info.idade = 1
# Enviar a estrutura de dados C para o consumidor
pipe.send(ctypes.byref(info))
def consumer(pipe):
# Receber a estrutura de dados C do produtor
info = ctypes.byref(pipe.recv())
# Imprimir as informações da estrutura de dados C
print(f"Nome: {info.nome}")
print(f"Idade: {info.idade}")
if __name__ == "__main__":
# Criar um canal de comunicação entre os processos
parent_conn, child_conn = multiprocessing.Pipe()
# Iniciar o produtor
p = multiprocessing.Process(target=producer, args=(child_conn,))
p.start()
# Iniciar o consumidor
c = multiprocessing.Process(target=consumer, args=(parent_conn,))
c.start()
# Aguardar a conclusão dos processos
p.join()
c.join()
Explicação:
A estrutura de dados C Info é definida com dois campos: nome e idade.
A função producer() cria uma instância da estrutura de dados Info e envia a estrutura de dados para o consumidor através do canal de comunicação.
A função consumer() recebe a estrutura de dados do produtor e imprime as informações da estrutura de dados para a console.
Vantagens de usar Python, ctype e multiprocess para compartilhar informações entre processos:
É possível compartilhar dados de qualquer tipo entre os processos, incluindo dados complexos, como estruturas de dados C.
O código é simples e eficiente.
Desvantagens de usar Python, ctype e multiprocess para compartilhar informações entre processos:
É necessário ter conhecimento de C para definir as estruturas de dados C que serão compartilhadas entre os processos.
Outras opções:
É possível usar a biblioteca multiprocessing.shared_memory para compartilhar dados entre os processos. Essa biblioteca fornece uma maneira mais simples de compartilhar dados entre os processos, mas é limitada a dados de tipos simples, como números inteiros, números de ponto flutuante e strings.
É possível usar a biblioteca ray para compartilhar dados entre os processos. Essa biblioteca fornece uma maneira mais eficiente de compartilhar dados entre os processos, mas é mais complexa de usar.
sincronizar processos
melhora o codigo de 10 de execucao pra 1s usando multiprocess
import datetime
import math
import multiprocessing
from concurrent.futures.process import ProcessPoolExecutor
def main():
qtd_cores = multiprocessing.cpu_count()
print(f'Realizando o processamento matemático com {qtd_cores} core(s).')
inicio = datetime.datetime.now()
with ProcessPoolExecutor(max_workers=qtd_cores) as executor:
for n in range(1, qtd_cores + 1):
ini = 50_000_000 * (n - 1) / qtd_cores
fim = 50_000_000 * n / qtd_cores
print(f'Core {n} processando de {ini} até {fim}')
executor.submit(computar, inicio=ini, fim=fim)
tempo = datetime.datetime.now() - inicio
print(f"Terminou em {tempo.total_seconds():.2f} segundos.")
def computar(fim, inicio=1):
pos = inicio
fator = 1000 * 1000
while pos < fim:
pos += 1
math.sqrt((pos - fator) * (pos - fator))
if __name__ == '__main__':
main()
"""
Terminou em 1.30 segundos.
"""
