Pool multiprocessante em Python
Sintaxe da função pool ():
Construímos explicitamente procedimentos na classe de processo. Embora a aula de piscina pareça mais útil porque podemos lidar com isso dinamicamente. Para construir um objeto de pool, utilize a sintaxe:
Todo parâmetro é opcional. O 'Initargs' é o terceiro parâmetro passado para o método, o segundo parâmetro 'Inicializador' também será fornecido, que é usado para inicialização. O 'maxtasksperchild' indica o número total de operações que todo processo infantil foi dado. O processo seria atualizado com um novo procedimento de trabalhador após a conclusão das operações.
Vamos discutir um grupo de multiprocessos adicionais:
Exemplo nº 1:
Vamos dar uma olhada na ilustração abaixo, que calcula o quadrado do número inteiro e acomoda o código para um segundo.
do pool de importação multiprocessante
Def Square (a):
print (f "Aqui o processo começa: a")
quadrado = a * a
print (f "quadrado a: square")
tempo.sono (1)
Imprima (f "Era o processo termina: a")
Se __name__ == "__main__":
start_t = tempo.tempo()
piscina = piscina ()
piscina.mapa (quadrado, alcance (0, 9))
piscina.fechar()
end_t = tempo.tempo()
print (f "O tempo total gasto é end_t-start_t segundos")
No início do código, temos que importar o módulo de tempo e o módulo de pool. A biblioteca da piscina será integrada do multiprocessamento. Definimos o quadrado da função (). Em seguida, utilizamos o método print () para mostrar a mensagem 'Aqui o processo começa'. Aqui, temos o quadrado do número multiplicando o número um com o outro. Mais uma vez, chamamos a função print () para mostrar o quadrado do número definido. Definimos a função Sleep () para definir o prazo do código.
Agora, a declaração de impressão imprime a linha que mostra que o processo é encerrado. Vamos começar com o corpo da função principal. Invocamos o método Time () do tempo do módulo. Construímos um item de aula de piscina. O método que gostaríamos de replicar e um iterável foi fornecido como parâmetros ao método map ().
Além disso, ele aceita um parâmetro adicional de 'Chunksize' que divide o iterável em segmentos de tamanho igual e recebe este como uma operação distinta. O parâmetro para o método map () é aplicado como o intervalo. Para negar novas operações, utilize a piscina.Método Close ().
Exemplo nº 2:
Nesse caso, definiremos o quadro de dados do código por 2 segundos usando o método Sleep ().
do pool de importação multiprocessante
Def Square (a):
print (f "O processo começa agora a")
quadrado = a * a
tempo.sono (2)
print (f "O processo termina agora a")
Retornar quadrado
Se __name__ == "__main__":
piscina = piscina ()
x = piscina.mapa (quadrado, alcance (0, 7))
impressão (x)
O pacote de tempo e o pacote de pool devem ser importados no início do programa. O multiprocessamento será incorporado com a biblioteca da piscina. O método square () é definido. A mensagem "O processo começa agora" é mostrado utilizando a função print (). Ao multiplicar os valores juntos, podemos obter o quadrado do número neste cenário.
Para definir o tempo do código, invocamos o método Sleep (). Além disso, o comando de impressão exibe uma linha indicando que o processo terminou. Dentro do corpo da função principal, invocaremos o método Pool (). O mapa de função () foi usado na próxima linha. Esta função contém dois parâmetros. O primeiro argumento mostra o quadrado do número. E o segundo parâmetro usa o método range ().
Definimos os limites inferiores e mais altos dentro da função Range (). No final, estamos chamando a Print () para mostrar o resultado.
Exemplo nº 3:
Incrivelmente semelhante à piscina.Map () Função é o pool.IMAP (). A distinção aqui é que o resultado de todo elemento é fornecido tão imediatamente quanto processado, em vez de ter que esperar que todos os itens sejam concluídos. Além disso, o iterable é transformado em um conjunto pela função map (). A técnica iMap (), portanto, não.
do pool de importação multiprocessante
Def Square (x1):
Print (f "STHE Process iniciou x1")
quadrado = x1 * x1
tempo.sono (9)
print (f "O processo terminou x1")
Retornar quadrado
Se __name__ == "__main__":
piscina = piscina ()
x2 = piscina.IMAP (quadrado, alcance (0, 4))
para j em x2:
print (f "O resultado está aqui j")
Primeiro, devemos incluir o tempo e a estrutura da piscina. Pegamos a biblioteca da piscina do pacote multiprocessante. Chamamos a função Square (). Esta função contém o número necessário como seu argumento. Para exibir a mensagem indicando que o processo começou, estamos chamando a função print (). Ao multiplicar os valores juntos neste caso, podemos obter o quadrado do número especificado. Para determinar o tempo do código, invocamos o método Sleep (). A afirmação que indica que o processo terminou foi impresso pela função de impressão. O quadrado do número inteiro especificado é então devolvido pela função.
Vamos começar o corpo da função principal agora. A função Pool () será usada. A próxima linha usa o método map (). Existem dois parâmetros para este método. O quadrado do número inteiro é fornecido como o primeiro parâmetro. A função range () está sendo usada como o segundo argumento. Dentro do método range (), as limitações inferiores e superiores são especificadas. Antes de terminar o código, utilizaremos o loop 'para'. Inicializamos a variável de loop. Este loop itera até que a condição fornecida seja cumprida. Depois disso, o método print () é aplicado para representar o resultado.
Conclusão
Neste guia, conversamos sobre o conjunto multiprocessante de Python. Quando numerosos processos precisam operar simultaneamente ou uma operação longa teria que ser acelerada, o multiprocessamento é vital. Quando um processo é executado em um único fio, seus recursos são restringidos; Caso contrário, isso esticaria seus tentáculos através de vários fios. O Python oferece uma interface simples para implementar o multiprocessamento se a operação demorada puder executar simultaneamente e todo o sistema suporta muitas arquiteturas de processador. Executamos três instâncias em que definimos o prazo do código.