O multiprocessamento em Python é um built-in pacote que permite ao sistema executar vários processos simultaneamente. Isso permitirá a divisão de aplicativos em threads menores que podem ser executados de forma independente. O sistema operacional pode então alocar todos esses threads ou processos ao processador para executá-los paralelamente, melhorando assim o desempenho geral e a eficiência.
Por que usar multiprocessamento em Python?
Realizando várias operações para um único processador torna-se um desafio. À medida que o número de processos continua aumentando, o processador terá que interromper o processo atual e passar para o próximo, para mantê-lo funcionando. Assim, ele terá que interromper cada tarefa, prejudicando assim o desempenho.
Você pode pensar nele como um funcionário de uma organização com a tarefa de realizar trabalhos em vários departamentos. Se o funcionário tiver que gerenciar as vendas, contas e até mesmo o back-end, ele terá que interromper as vendas quando estiver em contas e vice-versa.
Suponha que haja funcionários diferentes, cada um para executar uma tarefa específica. Torna-se mais simples, certo? É por isso que o multiprocessamento em Python se torna essencial. Os encadeamentos de tarefas menores agem como funcionários diferentes, facilitando o manuseio e gerenciamento de vários processos. Um sistema de multiprocessamento pode ser representado como:
Um sistema com mais de um único processador central Um processador de vários núcleos, ou seja, uma única unidade de computação com várias unidades de processamento de núcleo independentes
No multiprocessamento, o sistema pode se dividir e atribua tarefas a diferentes processadores.
O que é o módulo de multiprocessamento?
O módulo de multiprocessamento Python fornece vários classes que nos permitem construir programas paralelos para implementar multiprocessamento em Python. Ele oferece uma API fácil de usar para dividir processos entre vários processadores, aproveitando totalmente o multiprocessamento. Ele supera as limitações do Global Interpreter Lock (GIL) usando subprocessos em vez de threads As classes principais do módulo de multiprocessamento Python são:
Process Queue Lock
Vamos usar um exemplo para entender melhor o uso do módulo de multiprocessamento em Python.
Exemplo-Usando a classe de processo para implementar multiprocessamento em Python
# importing Python multiprocessing module
importar multiprocessamento
def prnt_cu (n):
print (“Cubo: {}”. formato (n * n * n))
def prnt_squ (n):
print (“Quadrado: {}”. format (n * n))
if __name__==”__main __”:
# criando vários processos
proc1=multiprocessing.Process (target=prnt_squ, args=(5,))
proc2=multiprocessing.Process (target=prnt_cu, args=(5,))
# Processo de iniciação 1
proc1.start ()
# Processo de iniciação 2
proc2. start ()
# Esperando até que proc1 termine
proc1.join ()
# Esperando até que proc2 termine
proc2.join ( )
# Processos concluídos
print (“Ambos os processos concluídos!”)
Resultado
Agora, é hora de entender o código acima e ver como o módulo de multiprocessamento e a classe de processo ajudam a construir programas paralelos.
Você primeiro usou o comando “import multiprocessing” para importar o módulo. Em seguida, você criou os objetos da classe Process: proc1 e proc2. Os argumentos passados nesses objetos foram: target: As funções a serem usadas args: Argumentos a serem dados nas funções Após a construção do objeto, deve-se usar o método start () para iniciar os processos. Por último, você usou o método join () para interromper a execução do programa atual até que ele execute os processos. Portanto, o programa executará primeiro proc1 e proc2. Em seguida, ele voltará para as seguintes instruções do programa em execução.Curso grátis: introdução ao Numpy
Domine os fundamentos do Numpy Inscreva-se agora
Para que servem os Pipes no multiprocessamento em Python?
Ao usar o multiprocessamento em Python, os Pipes atuam como o canal de comunicação. Pipes são úteis quando você deseja iniciar a comunicação entre vários processos. Eles retornam dois objetos de conexão, um para cada extremidade do Pipe, e usam os métodos send () e recv () para se comunicar. Vejamos um exemplo para um entendimento claro. No código abaixo, você usará um Pipe para enviar algumas informações do filho para a conexão pai.
importar multiprocessamento
do processo de importação de multiprocessamento, Pipe
def exm_function (c):
c.send ([‘Olá! Esta é a informação do filho’])
c.close ()
if __name__==’__main__’:
par_c, chi_c=Pipe ()
mp1=multiprocessing.Process (target=exm_function, args=(chi_c,))
Mp1.start ()
print (par_c.recv ())
mp1.join ()
Saída
Para que servem as filas no multiprocessamento em Python?
A Fila em Python é uma estrutura de dados baseada no conceito FIFO (First-In-First-Out). Assim como o Pipe, até mesmo uma fila ajuda na comunicação entre diferentes processos de multiprocessamento em Python. Ele fornece os métodos put () e get () para adicionar e receber dados da fila. Aqui está um exemplo para mostrar o uso de fila para multiprocessamento em Python. Este código irá criar uma função para verificar se um número é par ou ímpar e inseri-lo na fila. Você irá então iniciar o processo e imprimir os números.
importar multiprocessamento
def even_no (num, n):
para i em num:
if i% 2==0:
n.put (i)
if __name__==”__main__”:
n=multiprocessamento.Queue ()
p=multiprocessamento.Process (target=even_no, args=(range (10), n))
p.start ()
P.join ()
enquanto n:
print (n.get ())
Saída
Curso GRATUITO de ciência de dados com Python
Comece a aprender dados Ciência com Python GRATUITAMENTE Comece a aprender
Quais são as fechaduras usadas na Multipro cessando em Python?
O bloqueio é usado para bloquear os processos ao usar multiprocessamento em Python. Com seus métodos activate () e release (), você pode bloquear e retomar processos. Assim, permite que você execute tarefas específicas com base na prioridade enquanto interrompe os outros processos. O código a seguir usa o mecanismo de bloqueio em um sistema semelhante a ATM.
multiprocessamento de importação
# Função de retirada
def wthdrw (bal, lock):
para _ no intervalo (10000):
lock.acquire ()
bal.value=bal.value-1
lock. release ()
# Função de depósito
def dpst (bal, lock):
para _ no intervalo (10000):
lock.acquire ()
bal.value=bal.value + 1
lock.release ()
def transact ():
# saldo inicial
bal=multiprocessing.Value (‘i’, 100)
# criando objeto de bloqueio
lock=multiprocessing.Lock ()
# criando processos
proc1=multiprocessing.Process (target=wthdrw, args=(bal, lock))
proc2=multiprocessing.Process (target=dpst , args=(bal, lock))
# processos iniciais
proc1.start ()
proc2.start ()
# esperando o término dos processos
proc1.join ()
proc2.join ()
# imprimindo saldo final
imprimir (“Saldo final={}”. Formato (bal.value))
se __name_ _==”__main__”:
para _ no intervalo (10):
# realizando o processo de transação
transact ()
Saída
Olhando ansioso para fazer uma mudança para o campo da programação? Participe do Python Training Course e comece sua carreira como um programador Python profissional
Conclusão
Neste artigo, você aprendeu sobre o que é multiprocessamento em Python e como usá-lo. O uso mais prático do multiprocessamento é compartilhar recursos da CPU e operações ATM, como você viu no último exemplo. Por causa da facilidade que ele oferece para gerenciar vários processos, o conceito de multiprocessamento em Python, sem dúvida, ganhará muita força. Será uma jogada inteligente obter uma compreensão firme e prática prática.
Se você é um novato e isso é muito difícil de digerir, você pode começar a aprender o básico primeiro. Você pode consultar o Tutorial de Python para iniciantes do Simplilearn para se familiarizar com os conceitos básicos do Python. Depois de esclarecer o básico, você pode optar por nosso Python online Curso de certificação para se destacar no desenvolvimento Python.
Você tem alguma pergunta para nós? Deixe-os na seção de comentários deste artigo. Nossos especialistas entrarão em contato com você da mesma forma, o mais rápido possível.
Bom aprendizado!
