Python Multithreading

“Dentro de um processo, uma unidade de execução é conhecida como um tópico. Ao mover rapidamente a atenção da CPU entre os threads, vários threads podem ser executados simultaneamente em um processo conhecido como multithreading (também chamado de comutação de contexto). O básico do Python Multithreading será abordado neste artigo. Para sua ajuda, também forneceremos uma variedade de exemplos.”

Multithreading em Python

Multithreading é uma técnica de rosqueamento usada na programação Python para executar muitos threads ao mesmo tempo. Além disso, permite o compartilhamento de seu espaço de dados com os threads primários dentro de um processo, que se comunicam e compartilham informações mais facilmente do que processos separados. O objetivo do multithreading é realizar vários processos simultaneamente, o que melhora a renderização e o desempenho do aplicativo.

É um método muito prático para acelerar e aprimorar a funcionalidade de um aplicativo. Ao usar o Multithreading, um programador pode dividir as tarefas do aplicativo em trabalhos menores e executar várias instâncias do programa de uma só vez. Ele permite que os threads se comuniquem e compartilhem recursos do processador, incluindo memória, arquivos e dados. Além disso, torna os usuários mais dispostos a continuar usando um programa, mesmo quando uma seção está bloqueada ou muito longa.

Exemplo 1

Aqui está um programa Python simples para multithreading. Vejamos um programa Python que tem duas classes, "Python_demo" e "Python_lesson.”Vamos analisar esse código de amostra em detalhes.

Duas de nossas classes usam técnicas semelhantes. A saída da função de execução do objeto da primeira classe quando é construída e impressa a frase “Python Demo” quatro vezes. A palavra "lição de python" aparece quatro vezes quando repetimos o processo para a segunda classe.

Classe python_demo:
def run (self):
para i no intervalo (4):
Print ("Demo Python")
Classe python_lesson:
def run (self):
para i no intervalo (4):
Print ("Lição de Python")
primeiro_obj = python_demo ()
Second_obj = python_lesson ()
primeiro_obj.correr()
Second_obj.correr()

O resultado se executarmos este programa é o seguinte. Demo Python e lição de Python são mostradas quatro vezes em sucessão, como você pode ver. Como resultado, o tópico principal é onde este programa é executado. Cada programa contém o tópico principal. Nesse caso, ambas as operações são realizadas em uma sequência.

Exemplo 2

Empregaremos o módulo de encadeamento de Python como exemplo. Podemos entender a necessidade de multithreading se considerarmos o primeiro cenário. Isso implica que ambos os procedimentos devem ser usados ​​simultaneamente. A classe de threads e pacote de threads do Python podem ser usados ​​para conseguir isso. Vamos tentar pensar em algo. Agora que o multithreading está presente, o programa de amostra foi atualizado. Além disso, cada classe foi executada como seu próprio tópico usando a classe Thread.

Também fizemos a diferença por não chamar diretamente o método de execução. Em vez disso, utilizamos o método de início, que é basicamente o mecanismo de implementação de encadeamento.

Quando aplicamos o método de início, a função de execução é chamada instantaneamente em segundo plano. Atualmente executamos o tópico principal por padrão. Dois fios infantis, primeiro OBJ e segundo OBJ, são formados quando os métodos de início são chamados.

De importação de importação *
classe python_demo (thread):
def run (self):
para i no intervalo (4):
Print ("Demo Python")
classe python_lesson (thread):
def run (self):
para i no intervalo (4):
Print ("Lição de Python")
primeiro_obj = python_demo ()
Second_obj = python_lesson ()
primeiro_obj.começar()
Second_obj.começar()

Esses ajustes resultam na saída que é exibida abaixo. Agora que o aplicativo está em execução, o multithreading pode estar acontecendo. Podemos ver que várias palavras estão agrupadas, apesar do fato de que "Python Demo" e "Python Lição" são duas frases separadas. Isso resultou de uma colisão. Isso acontece como resultado de dois threads (First_OBJ e Second_Obj) tentando executar na CPU simultaneamente devido à velocidade excessiva do processador.

Exemplo 3

Os programadores do sistema operacional especificam o tempo para execução. Neste exemplo, as instruções são realizadas pelo software mais de uma vez em um horário específico.

Podemos evitar isso usando a abordagem do sono para fornecer um pequeno atraso ao nosso software. Para conseguir isso, devemos importar a função de sono do módulo de tempo para adicionar uma breve pausa entre a execução dos dois threads. Exceto pela adição da função do sono, o código é praticamente idêntico aos exemplos de antes.

Observe os módulos necessários, rosquear e dormir. Esses módulos são importados primeiro. A função de sono é então executada em duas classes que são construídas posteriormente. Para imprimir a frase um certo número de vezes em nosso caso, três nós utilizaram o loop for em ambas as classes. Para executar o aplicativo, invocamos o método START () depois de implementar a abordagem de rosqueamento. As linhas finais de código do programa demonstram isso.

De importação de importação *
Desde o tempo de importação do sono
classe python_demo (thread):
def run (self):
para i no intervalo (3):
Print ("Demo Python")
sono (1)
classe python_lesson (thread):
def run (self):
para i no intervalo (3):
Print ("Lição de Python")
sono (1)
primeiro_obj = python_demo ()
Second_obj = python_lesson ()
primeiro_obj.começar()
sono (0.3)
Second_obj.começar()

O resultado agora demonstra que os threads estão funcionando simultaneamente.

Exemplo 4

O módulo de rosqueamento no Python é usado para construir roscas no seguinte snippet de código. O encadeamento principal é executado no código, e as palavras "este é o encadeamento principal" são impressas. O primeiro tópico e o segundo tópico são dois tópicos recém -estabelecidos e em execução. Há uma transição de contexto, e o primeiro tópico começa a correr.

O primeiro tópico vai dormir após as quatro primeiras iterações, enquanto o segundo tópico começa a funcionar e completa bem a tempo para a próxima chave de contexto.

A CPU está agora sob o controle do fio principal, que escreve “Tópico principal novamente!”

O segundo fio retoma sua execução após outra troca de contexto e completa. O encadeamento principal não pode mais executar mais instruções; Portanto, o programa termina.

importar rosqueamento como TD
Tempo de importação como T
DEF Print_welcome ():
para i no intervalo (5):
Se eu == 4:
t.sono (2)
print ("Welcome")
DEF Print_integers (n):
para i no intervalo (n+1):
impressão (i)
Imprimir ("Este é o tópico principal.")
primeiro_thread = td.Thread (Target = print_welcome, args = ())
Second_thread = td.Thread (Target = print_integers, args = (10))
primeiro_thread.começar()
Second_thread.começar()
Imprimir ("Tópico principal novamente!")

Você pode ver a saída nesta seção, onde o encadeamento principal é executado primeiro, e a mensagem é repetida conforme necessário. Após a execução do segundo tópico, que exibiu os números, o software retornou ao primeiro tópico e desempenhou a função que mostra a palavra “Bem -vindo.”

Conclusão

O tópico deste artigo foi Python Multithreading. Ao alternar rapidamente entre roscas usando uma CPU, o multithreading é uma técnica de rosqueamento usada na programação Python para executar muitos threads simultaneamente. Além disso, permite o compartilhamento de seu espaço de dados com os threads primários dentro de um processo, que se comunicam e compartilham informações mais facilmente do que processos separados. O objetivo do multithreading é realizar vários processos simultaneamente.