ThreadpoolExecutor Python

ThreadpoolExecutor é uma classe Python encontrada em seu pacote chamado “Concorrente.futuros ”. Digamos que precisávamos fazer muitos tópicos em nossos trabalhos altamente paralelosos. É o mais caro, porque pode haver várias preocupações de eficiência como resultado de ter muito mais processos. Uma grande preocupação pode ser que a taxa de transferência seja restrita. Você pode superar esse problema construindo um pool de threads. Um pool de threads é uma coleção de processos pré-instantados ou inativos que estão esperando para receber o trabalho. Sempre que um conjunto significativo de atividades deve ser concluído, o estabelecimento de um pool de threads geralmente é recomendado para desenvolver novos processos para cada trabalho. Um pool de threads pode realizar as seguintes tarefas:

• Depois que um processo dentro de um pool de threads concluiu seu processamento, ele poderá ser usado novamente.
• Quando um tópico termina, um novo tópico é formado para tomar seu lugar.

O concorrente.O pacote futuro é uma parte da biblioteca regular do Python. Em Python 3.2, este pacote foi criado para dar aos programadores uma interface elevada para iniciar processos simultâneos. Esse é um nível intermediário construído sobre a multitarefa da Python, bem como pacotes multiprocessantes que permitem executar tarefas utilizando um pool de threads ou procedimentos. Neste artigo, daremos uma olhada na classe Executor do Pool de threads e suas funções.

Exemplo 01:

Vamos dar uma olhada na classe Executor do Pool de threads em nosso código Python. Em primeiro lugar, usamos o “simultâneo.Pacote Futures "usando a palavra -chave" de "na primeira linha para importar a classe" ThreadpoolExecutor "no código. Depois disso, inicializamos uma lista de 4 números. A primeira função é uma função definida pelo usuário chamada "Square" e estará calculando um quadrado de um valor passado em seus argumentos. O outro método é a função do construtor i.e., o método main () quando a execução começa em i. Portanto, a função definida pelo usuário "quadrado" é definida usando a palavra-chave "def" e assume o valor do argumento para calcular seu quadrado.

Os suportes "" são usados ​​para tomar o valor numérico de uma variável "z" em vez de tomar "z" como uma string aqui. Caractere “f” antes da declaração de texto e cálculo mostra que os valores serão tomados como flutuadores e seu quadrado será calculado. A declaração de impressão está utilizando este formato para obter um quadrado e imprimi -lo no shell de saída Spyder3. Agora, aqui vem o construtor de função principal (). O construtor está inicializando uma lista vazia chamada "Val". É hora de usar a classe ThreadpoolExector para fazer um pool de 5 threads para serem usados ​​de forma assíncrona.

Para isso, use a declaração "com" com o nome "ThreadpoolExector", assumindo um argumento "max_workers" com o valor 5. Você pode vê -lo como um loop assumindo um valor de cada vez. A função de envio da classe ThreadpoolExector é usada para executar uma função i.e., "Quadrado" e produz um quadrado de um número passado a ele. Está levando o número 1 como valor inicial para o método quadrado e depois disso, ele levará os valores da lista "l". A função "mapa" é usada aqui para traduzir rapidamente a função e iterável coletivamente como um e levanta um erro no “simultâneo.pacote de futuros ”. A exceção será armazenada na variável "val" e a instrução de impressão será usada para exibir a exceção usada no loop "for" na tela de saída.

de simultâneo.Futuros Importar ThreadpoolExecutor
L = [2,3,4,5]
Def Square (Z):
print (f'Square de z: z*z ')
se __name__ == '__main__':
val = []
com threadpoolexecutor (max_workers = 5) como exe:
exe.Envie (quadrado, 1)
val = exe.mapa (quadrado, l)
para res em Val:
Imprimir (res)

O pool de 5 threads foi criado para calcular um quadrado de 5 valores a partir de 1 a 5, conforme exibido na saída.

Exemplo 02:

Aí vem o último exemplo de usar a classe ThreadpoolExector no código Python. Então, iniciamos esses novos exemplos com a importação de uma classe usando seu pacote “simultâneo.futuros ”. Em seguida, inicialize uma variável "soma" com 0 valor. A função definida pelo usuário chamada "processo" é declarada assumindo um argumento "n". Esta função está imprimindo os números de threads através da instrução de impressão. O número do encadeamento é resumido com o número 5 adicionado à variável "soma". Esta soma calculada para cada encadeamento será mostrada na saída que emprega a declaração de impressão. A definição do método principal foi iniciada aqui. Está usando o ThreadpoolExecutor para a criação de um pool de 3 threads. A função "processo" foi chamada 3 vezes usando a função "submeter" para 3 valores diferentes. Depois que todos os threads do método do processo são executados, ele exibirá a mensagem de conclusão. A declaração de função principal () é usada depois disso.

de simultâneo.Futuros Importar ThreadpoolExecutor
Soma = 0
Processo DEF (n):
print ("Processando o tópico: ".formato (n))
Soma = n + 5
print ("A soma de e 5 é:".formato (n), soma)
def main ():
print ("Iniciando ThreadpoolExecutor")
com threadpoolexecutor (max_workers = 3) como ex:
val = ex.enviar (processo, (2))
val = ex.enviar (processo, (4))
val = ex.enviar (processo, (5))
Imprimir ("Todos os threads são processados ​​completamente")
se __name__ == '__main__':
principal()

A execução mostra que o pool é iniciado e cada número de thread com sua soma com o número 5 é exibido.

Conclusão:

Cobrimos e discutimos a classe ThreadpoolExector e todas as funções possivelmente usadas em nossos exemplos. Devemos torná -lo tão despretensioso quanto provável para nossos usuários. Demos uma olhada em um mapa e enviamos função também. Estamos esperando a melhor resposta.