Python Kill Thread

Embora não possamos matar threads em python, existem algumas técnicas que podemos usar para simular a matança de threads em python. Matar um fio em python de repente é considerado uma abordagem de programação ruim, pois não podemos matar o fio diretamente. Em vez disso, devemos usar um dos métodos fornecidos pela Python. Esses métodos encerrarão com precisão os fios, mas estão bem próximos do processo.

Criando um tópico em Python

Quando você executa um programa, um tópico é um fluxo separado de execução que é executado no fundo do programa. Os threads python são um tipo de processo que pode ter sua execução planejada. Um tópico é, para simplificar, um processo de computação que um computador realizará. O conjunto de instruções de um programa pode ser realizado separadamente de outros códigos. O encadeamento de segundo plano não pode ser encerrado corretamente no Python, mas existem outras técnicas que podemos usar se ainda desejarmos encerrar o tópico. Esses métodos, no entanto, não encerram o encadeamento corretamente; Em vez disso, eles são apenas muito úteis para fazê -lo. Mas aqui, primeiro demonstraremos como iniciar um tópico antes de mostrar como impedi -lo.

Vamos executar o código. Primeiro, importamos as bibliotecas "Time" e "Thread". Então, na linha a seguir, definimos a função "func1". Na linha a seguir, usamos um loop para iniciar a variável "x" e definir o intervalo para as iterações do fio. Aqui, definimos o intervalo de "1" para "10", o que significa que nosso tópico vai parar após "10" iterações. Na linha seguinte, chamamos de “tempo.sono (), ”com um intervalo de tempo de“ 1 ”. Usamos o “tempo.Sleep () ”função quando queríamos atrasar a execução de uma declaração.

Em seguida, chamamos a função print () dentro desta função. Passamos a variável "X", na qual o número de iterações foi armazenado e também passou a declaração de entrada, “iterações concluídas antes de desistir”. À medida que definimos o tempo para "1", o sistema entrará no modo de suspensão para "1" antes de imprimir a declaração de impressão. Então, na linha a seguir, chamamos essa função de "func" com o módulo "Thread". Aqui, inicializamos a variável "T" para armazenar threads. Então, nós usamos o “t.função start () ”para iniciar o tópico. E chamamos a função "junção ()" com threads O método "junção ()" suspende a implementação de um programa até que o tópico de destino seja lido na íntegra.

Depois que o tópico tiver concluído suas iterações "10", o sistema pausa sua operação por "1" segundo antes de imprimir a frase "completará as iterações antes de parar de parar.”Agora, quando chamamos a função com Thread, ele começará a execução do thread à medida que definimos acima do loop e seu intervalo é“ 10 ”.

Agora que mostrou todas as suas iterações na saída, é impossível matar o tópico aqui. Quando clicamos. Este tópico apenas entende que precisa terminar suas iterações "10".

Usando o fio daemon para matar o tópico

Agora, não podemos matar o tópico usando este método. No entanto, podemos impedir que o tópico termine usando esse método simplesmente encerrando sua execução após um período de tempo definido, o tópico não é interrompido no back -end. Os threads que administram em segundo plano que suportam continuamente os fios primários ou não danos, executando em primeiro plano são conhecidos como linhas de daemon. O fio daemon que funciona em segundo plano não impede que o tópico morra.

Vamos iniciar o código importando três bibliotecas: "Threading" é o primeiro, seguido de "tempo" e "sys", respectivamente. Numerosos métodos e variáveis ​​no pacote python sys podem ser usados ​​para alterar diferentes componentes do sistema operacional Python. Trabalhar no intérprete é possível por sua acessibilidade a constantes e métodos que têm uma conexão estreita com o intérprete. Após a criação de uma função com o nome "func", usamos uma condição "enquanto verdadeira" para funcionar condicionalmente até que a declaração fosse executada dentro do loop.

Então, na próxima linha, usamos a função "print ()" para imprimir a frase, "Thread está ativo, mas desaparecerá quando o programa terminar", depois de passar o tempo "1" segundos no "tempo.Sleep () ”função. Como usamos “tempo.Sleep () "acima para definir o tempo como" 1 "segundos, a declaração agora entrará no modo de suspensão por um segundo antes de produzir este método. Então, na linha a seguir, usamos o daemon e sua propriedade para "verdadeiro" para nos permitir encerrar nossos tópicos após uma quantidade predeterminada de tempo.

Atualmente, estamos gerando um tópico usando “Threading.thread "e usando" Target = func "para chamar a função no thread. Agora que usamos “t.start () ”para iniciar nosso tópico, chamamos de“ sys.saída () ”, que fará com que o sistema jogue uma exceção de saída do sistema. Então, o que esse código realmente faz é exibir a declaração de impressão que foi salva na função "func" quando o tópico chama, mas atrasa a impressão da declaração por "1" segundos porque usamos "tempo.dormir().”

Como você pode ver, o tópico está em execução atualmente, mas quando estava prestes a concluir sua oitava iteração, pressionamos o Ctrl-C, que imediatamente interrompeu o término do tópico. Isso significa essencialmente que, usando um fio daemon, não conseguimos realmente matar o tópico, apenas para impedir que ele corra. Esta não é a maneira mais eficiente de encerrar o thread; Em vez disso, devemos terminar toda a operação.

Como não é possível forçar o tópico a terminar interrompendo -o com o teclado, agora estamos usando o objeto Python Events no próximo script. Isso fará com que o tópico pare por conta própria. Não precisamos acertar nenhuma chave para impedir que ela termine. Este objeto de evento é oferecido no módulo Thread. Possui dois métodos especificados: set () e não set ().

Vamos começar implementando o código importando os pacotes "sinal", "encadeamento" e "tempo". A próxima linha usa “Threading.evento () ”para invocar o evento do tópico. Então, na linha a seguir, usamos a função de impressão () e dentro dela, chamamos a declaração de entrada, passando o argumento “i de 20 iterações."Estamos imprimindo o valor de" eu "na variável" f ", que é de" 20 "iterações. Então, na linha a seguir, usamos um loop para e dentro dela, criamos a variável "i" e definimos o intervalo para "1" como "20". Então, usamos a condição "se" que seja se saia.evento.está definido (), ele quebra o loop, o que significa que se o evento for definido (), então termina. Estamos usando a função print () para imprimir a declaração que é "iterações concluídas antes de sair" e imprimir o valor "i" na variável "f". Usamos a condição "se" que seja se saia .evento.está definido () então quebre o loop.

Em seguida, criamos uma nova função com o nome "manipulador de sinal" para o qual passamos as variáveis ​​"siglum" e "quadro". Depois de usar o exit_event.set (), chamamos as funções de "manipulador de sinal" com sinal.sinalize e função "func" com "rosqueamento.thread ", respectivamente. Finalmente, usamos a função de junção () no final para conectar as duas funções.

Como você pode ver na exibição do resultado, definimos o intervalo para "20", o que indica que o cálculo terminará após vinte iterações, mas, neste caso, terminou após cinco iterações, apesar de não clicar em nenhuma chave de interrupção do teclado. Isso indica que o fio não foi morto, mas terminado, o que é benéfico para a apresentação.

Conclusão

Neste artigo, discutimos como matar um tópico em Python, no entanto, descobrimos que, embora possamos interromper a execução de um tópico após um certo número de iterações, não podemos matar um tópico em python. Criamos um tópico pela primeira vez e depois usamos um fio daemon para matá -lo. Mesmo assim, descobrimos que, enquanto usamos este módulo, poderíamos parar imediatamente a execução do tópico digitando Ctrl-C, e o tópico não seria morto. O tópico será interrompido instantaneamente após uma certa quantidade de execução quando usamos objetos de evento Python, o que foi útil.