Multiprocessamento de Python para loop

O multiprocessamento é comparável ao multithreading. No entanto, ele diferencia que só podemos executar um tópico em um momento devido ao GIL que é empregado para rosquear. Multiprocessamento é o processo de execução de operações sequencialmente em vários núcleos da CPU. Os threads não podem ser operados em paralelo. No entanto, o multiprocessamento nos permite estabelecer os processos e executá -los simultaneamente em vários núcleos da CPU. O loop, como o loop for, é um dos idiomas de script mais usados. Repita o mesmo trabalho usando vários dados até que um critério, como um número predeterminado de iterações, seja alcançado. O loop realiza cada iteração um por um.

Exemplo 1: Utilizando o loop for no módulo multiprocessamento de Python

Neste exemplo, usamos o loop for-loop e o processo de classe do módulo multiprocessante Python. Começamos com um exemplo muito direto para que você possa entender rapidamente como o multiprocessamento do python funciona. Usando uma interface comparável ao módulo de rosqueamento, o multiprocessamento embala a criação de processos.

Ao empregar os subprocessos em vez de threads, o pacote multiprocessante fornece simultaneidade local e distante, evitando assim o bloqueio global de intérprete. Use um loop for, que pode ser um objeto de string ou uma tupla, para iterar continuamente através de uma sequência. Isso tem um desempenho menos parecido com a palavra -chave vista em outras linguagens de programação e mais como um método de iterador encontrado em outras linguagens de programação. Ao iniciar um novo multiprocessamento, você pode executar um loop for que executa um procedimento simultaneamente.

Vamos começar implementando o código para execução de código, utilizando a ferramenta "Spyder". Acreditamos que "Spyder" também é o melhor para correr Python. Nós importamos um processo de módulo multiprocessante que o código está executando. O multiprocessamento no conceito Python denominado "Classe de Processo" cria um novo processo Python, fornece um método para executar o código e dá ao painel pai uma maneira de gerenciar a execução. A classe de processo contém os procedimentos iniciantes () e junção (), ambos cruciais.

Em seguida, definimos uma função definida pelo usuário chamada "func". Como é uma função definida pelo usuário, damos o nome de nossa escolha. Dentro do corpo desta função, passamos a variável "sujeito" como um argumento e o valor de "matemática". Em seguida, chamamos a função "print ()", passando a afirmação "o nome do assunto comum é", bem como seu argumento "sujeito" que contém o valor. Então, na etapa seguinte, utilizamos o “if name == _main_”, que impede que você execute o código quando o arquivo é importado como um módulo e apenas permite que você o faça quando o conteúdo é executado como um script.

A seção de condições que você começa pode ser pensada na maioria das circunstâncias como um local para fornecer o conteúdo que só deve ser executado quando seu arquivo é executado como um script. Em seguida, usamos o assunto do argumento e armazenamos alguns valores que são "ciência", "inglês" e "computador". O processo recebe o nome "Process1 []" na etapa seguinte. Em seguida, usamos o "Process (Target = func)" para chamar a função no processo. O destino é usado para chamar a função e salvamos esse processo na variável "P".

Em seguida, usamos o "Process1" para chamar a função "Append ()", que adiciona um item ao final da lista que temos na função "Func.”Como o processo é armazenado na variável“ P ”, passamos“ P ”para esta função como seu argumento. Por fim, usamos a função "start ()" com "p" para iniciar o processo. Depois disso, executamos o método novamente enquanto fornecemos o argumento do "sujeito" e o uso "para" no assunto. Em seguida, usando o método "Process1" e "Add ()" mais uma vez, começamos o processo. O processo é executado e a saída é retornada. O procedimento é então instruído a terminar usando a técnica "junção ()". Os processos que não chamam o procedimento "ingressos ()" não saem. Um ponto crucial é que o parâmetro de palavra -chave "args" deve ser usado se você quiser fornecer algum argumento através do processo.

Agora, você pode ver na saída que a declaração é exibida primeiro, passando o valor do assunto "Matemática" que passamos para a função "func" porque primeiro o chamamos de uso da função "processo". Em seguida, usamos o comando "Append ()" para ter valores que já estavam na lista que é adicionada no final. Então, “ciência”, “computador” e “inglês” foram apresentados. Mas, como você pode ver, os valores não estão na sequência correta. Isso ocorre porque eles o fazem tão rapidamente quanto o procedimento é concluído e relatar sua mensagem.

Exemplo 2: Conversão de loop seqüencial para loop paralelo multiprocessante

Neste exemplo, a tarefa de loop multiprocessante é executada sequencialmente antes de ser convertida em uma tarefa paralela para o loop. Você pode percorrer sequências como uma coleção ou string na ordem em que elas ocorrem usando os loops para.

Agora, vamos começar a implementar o código. Primeiro, importamos “sono” do módulo de tempo. Usando o procedimento "Sleep ()" no módulo de tempo, você pode suspender a execução do tópico de chamada pelo tempo que quiser. Em seguida, usamos "aleatório" do módulo aleatório, definimos uma função com o nome "func" e passamos a palavra -chave "argumento". Em seguida, criamos um valor aleatório usando "val" e o definimos como "aleatório". Em seguida, bloqueamos por um pequeno período usando o método "Sleep ()" e passamos "Val" como um parâmetro. Então, para transmitir uma mensagem, executamos o método "print ()", passando as palavras "prontas" e a palavra -chave "arg" como seu parâmetro, além de "criado" e passar o valor usando "val".

Finalmente, utilizamos "Flush" e o definimos como "True". O usuário pode decidir se deve ou não buffer a saída usando a opção Flush na função de impressão do Python. O valor padrão deste parâmetro de false indica que a saída não será buffer. A saída é exibida como uma série de linhas que se seguem se você o definir como true. Então, usamos o "if nome == main" para garantir os pontos de entrada. Em seguida, executamos o trabalho sequencialmente. Aqui, definimos o intervalo para "10", o que significa que o loop termina após 10 iterações. Em seguida, chamamos a função "print ()", passamos a instrução de entrada "pronta" e usamos a opção "Flush = true".

Agora você pode ver que, quando executarmos o código, o loop faz com que a função seja executada "10" vezes. Isso itera 10 vezes, começando no índice zero e terminando no índice nove. Cada mensagem contém um número de tarefa que é um número de função que passamos como um "arg" e um número de criação.

Este loop seqüencial agora está sendo transformado em um loop paralelo multiprocessante. Usamos o mesmo código, mas vamos a algumas bibliotecas e funções extras para o multiprocessamento. Portanto, devemos importar o processo do multiprocessamento, assim como explicamos anteriormente. Em seguida, criamos uma função chamada "func" e passamos a palavra -chave "arg" antes de usar "Val = aleatório" para obter um número aleatório.

Então, depois de invocar o método "Print ()" para mostrar uma mensagem e dar o parâmetro "val" para adiar um pouco de período, utilizamos a função "if nome = main" para proteger os pontos de entrada. Então, criamos um processo e chamamos a função no processo usando "processo" e passamos o "Target = func". Em seguida, passamos pelo "func", "arg", passamos o valor "m" e passando o intervalo "10", o que significa que o loop encerra a função após "10" iterações. Em seguida, iniciamos o processo usando o método "start ()" com "processo". Em seguida, chamamos o método "ingressos ()" para aguardar a execução do processo e concluir todo o processo depois.

Portanto, quando executamos o código, as funções chamam o processo principal e começam sua execução. Eles são feitos, no entanto, até que todas as tarefas sejam realizadas. Podemos ver isso porque cada tarefa é realizada simultaneamente. Ele relata sua mensagem assim que terminar. Isso significa que, embora as mensagens estejam fora de ordem, o loop termina depois de todas as iterações “10” são concluídas.

Conclusão

Cobrimos o multiprocessamento do Python para o loop neste artigo. Também apresentamos duas ilustrações. A primeira ilustração mostra como utilizar um loop for na biblioteca multiprocessante de loop de Python. E a segunda ilustração mostra como mudar um loop seqüencial para um loop paralelo de multiprocessamento. Antes de construir o script para o multiprocessamento do Python, devemos importar o módulo multiprocessamento.