Exemplo de multiprocessamento do Python

Python é uma linguagem de programação que é benéfica no desenvolvimento de sites e aplicativos. Além disso, envolvido na visualização e análise de dados. É comparativamente uma linguagem fácil e é frequentemente usada por não programadores. Este artigo refere -se ao uso de multiprocessamento em Python.

Multiprocessamento

Multiprocessing lida com o potencial de um sistema que suporta mais de um processador de cada vez. Todas as aplicações no multiprocessamento são demolidas em pequenos padrões, e cada um desses padrões é auto-dependente de trabalhar. Nesse tipo de processo, dois ou mais processos são usados. Basta considerar que um computador está executando com o uso de um único processador. Se atribuirmos vários processadores ao mesmo. Em outras palavras, se houver mais tarefas a serem executadas, mais difícil, será mantê -las no caminho de conclusão. Enquanto alocar cada tarefa de tempo igual é um grande desafio também. Nesta condição, precisamos surgir o conceito de multiprocessamento. Um sistema de multiprocessamento pode permitir.

• Multiprocessador: Um computador que usa mais de um processador central.
• Processador multi-core: Um único componente que usa duas ou mais unidades de processamento.

Multiprocessamento em Python

Usando o conceito de multiprocessamento, a unidade de processamento central pode executar facilmente várias tarefas em um único horário. Python usa o módulo multiprocessamento para introduzir códigos paralelos. Para implementar o multiprocessamento, você primeiro precisa saber sobre o número de núcleos em seu sistema. Usamos uma única peça de código aqui para saber sobre as CPUs trabalhando em cada vez.

Para Python, você pode usar qualquer outra ferramenta para realizar os códigos. Usamos a ferramenta Spyder para esse fim que certamente executará os códigos de linguagem Python.

Importar multiprocessamento

impressão ("Número de CPU:", multiprocessamento.cpu_count ())

Em primeiro lugar, precisamos importar o pacote "PG" multiprocessamento que permitirá o trabalho. Para cada PC, a saída pode variar. Para mim, o número de núcleos é 4.

Exemplo 1:

Usando um módulo multiprocessante, calcularemos as funções do cubo e quadrado.

Vamos entender o código acima mencionado. Criamos um processo e depois criamos um objeto para processar a classe.

P1 = multiprocessamento.Processo (print (print_cube (5))))
P2 = multiprocessamento.Processo (print (print_square (2,))))

P1 e P2 são os objetos dos processos. Esses processos contêm a chamada funcional com um recurso de impressão que chamará diretamente a função com argumentos como parâmetro. Print_cube e print_square.

Usamos métodos de início para iniciar o processo.

P1.começar()
P2.começar()

Uma das funções usadas é descrita como.

DEF Print_square (num):
print ("quadrado: ".formato (num * num))

A função quadrada calculará o quadrado multiplicando o número fornecido usado na chamada de função. A função leva o número na variável "num".

Quando executarmos o código, a saída exibirá os valores resultantes de ambas as funções.

Exemplo 2:

Usando estruturas de dados, você deve estar familiarizado com o uso de pilhas e filas na linguagem de programação. Do módulo multiprocessamento, importamos uma classe de fila aqui que é a estrutura de dados FIFO (primeiro a sair). Haverá dois processos que estão funcionando alternativamente. Usamos duas funções aqui. A função put () é usada aqui para inserir dados na fila. Considerando que usamos get () para recuperar os itens da fila. Abaixo está o código que ilustra o funcionamento do multiprocessamento na fila. O primeiro passo é introduzir filas.

Da fila de importação multiprocessante

Depois de importar o módulo, apresente os nomes dos carros na variável da matriz. Usaremos um loop for para inserir os valores dentro da fila, e o put () o fará. Uma variável "CNT" é usada para contar o número de carros usados. Inicialize o objeto da fila através da declaração.

Fila = fila ()

Então um loop é usado para adicionar valores; Isso usará uma palavra -chave "fila" para usar a função put () para argumentar como o nome do carro a ser inserido. A função "CNT" será incrementada após cada inserção.

Para carro em carros:

Fila.Put (carro)
Cnt += 1

Da mesma forma, para put (), um loop de tempo é usado até que toda a fila não esteja vazia.

Embora não esteja na fila.vazio():

Imprimir ('item no:', cnt, ", fila.pegar())
Cnt+= 1

A saída mostra as duas funções trabalhando de forma independente. Depois que uma função completa seu trabalho, o outro processo é usado.

Exemplo 3:

Este exemplo contém dois processos. Em cada processo, "PID" é obtido através da função get (). Nós usamos dois módulos. Um é multiprocessamento e o outro é o sistema operacional OS.

Cada processo é alocado um ID diferente.

DEF Process ():

Imprima (“Id de Process Running Worker1: ”.formato (OS.getpid ()))

A mensagem é concatenada com a chamada de função para receber o ID do processo. No programa principal, o ID principal do processo é recuperado usando a mesma abordagem através do get (). Em seguida, os processos são criados através do multiprocessamento. Cada processo é acessado através de seus respectivos objetos. eu.e., Para o processo 1, o objeto é P1.

P1 = multiprocessamento.Processo (Target = Process1)

Target é a função que deve ser executada pelo processo. À medida que os processos são criados, eles precisam começar. O status de cada processo é exibido; Para isso, precisamos monitorar a conclusão do processo. Isso precisará de algum tempo para esperar. Usaremos uma função que esperará até a execução completa do processo.

P1.juntar()

Quando esta função de junção recebe o sinal, ele imprime a afirmação de que a execução é concluída. Uma bandeira booleana determinará o processo vivo ou não; Se sim, então é verdade, caso contrário, é falso.

Print (“Processo P1 está vivo: ”.formato (p1.Está vivo()))

Agora execute o programa e pegue a saída. Você pode ver que primeiro, o ID principal é exibido e, em seguida, o ID do processo de cada processo. Depois que a execução é concluída, o status é exibido para os dois processos, que é "falso".

Exemplo 4:

Neste exemplo, você verá o funcionamento do multiprocessamento e tempo de importação, pool, cpu_count. O pool é usado para executar processos com várias entradas e distribuir esses dados de entrada entre os processos. Uma função quadrada calculará o quadrado do valor de entrada. Ao usar o módulo de tempo do pacote, usaremos a função de sono.

Tempo.sono (3)

Esta função tem uma expansão de tempo de 3 segundos. Isso significa que o valor desta função será mostrado após este horário específico. No programa principal, iniciamos o timer e, em seguida, os valores fictícios de cada 4 núcleos são alocados.

Com piscina () como piscina:

Res = pool.mapa (quadrado, valores)
Imprimir (res)

A função do pool está dando valores e chamando a função ao mesmo tempo. Então precisamos parar o cronômetro. Essa função do timer contará os segundos usados ​​para esta função, conhecida como tempo decorrido; é obtido subtraindo o valor inicial do tempo do valor final.

Agora execute o programa. A primeira linha é exibida e depois leva 3 segundos. Depois disso, outro resultado é mostrado.

Conclusão

"Exemplo de multiprocessamento de Python" é uma breve introdução ao fenômeno multiprocessante. Cada exemplo explicado aqui importa diferentes pacotes do módulo multiprocessamento. Esse manuseio de processos paralelos um ao outro é realizado através do número de CPUs. Mais o número de CPUs maiores será a chance de um bom multiprocessamento.