Threading em Python | O que é Threading em Python??

Rosca em Python: Torne seu código mais inteligente

Python é ótimo e sabemos disso. Mas, Você pode ser inteligente o suficiente no processamento de aspectos? Roscar mostra o caminho.

O que é paralelismo??

Máquinas anteriores costumavam ter um único núcleo dentro da CPU onde todo o processamento costumava ocorrer..

Por que o número de núcleos é importante? É porque indica a capacidade da máquina de lidar com várias coisas.. Clique no ícone do Windows na barra de tarefas 16 núcleos, pode executar 16 Diferentes operações ao mesmo tempo.

Suponha que você queira realizar 16 Diferentes operações de soma e suponha que cada operação leva 1 segundo. Em uma máquina de um núcleo único, Você deve realizar essas operações um por um, o que significa que 16 Adicionar operações são realizadas em 16 segundos. Agora, em um 16 núcleos, você pode implementar o 16 adicionar operações em cada núcleo ao mesmo tempo e fazer o trabalho em 1 segundo. Se chama Paralelismo.

Fio

Fio é um conjunto de operações que devem ser executadas. O segmento será implantado em um dos núcleos da CPU. Observação: 1 segmento só pode ser implementado em 1 núcleo, não pode ser transferido / troca de dentes

Vamos implantar dois fios em um núcleo. Observação: um núcleo só pode fazer uma coisa de cada vez.

Agora podemos processar os dois segmentos do jeito que queremos.

Primeiro, podemos processar metade do primeiro segmento.

Metade do próximo segmento agora pode ser processado.

A metade restante dos fios pode ser processada de forma semelhante.

Isso é o que é rosca É assim que executamos coisas diferentes no mesmo núcleo da CPU. TLDR- Roscar é sobre como lidamos com fios em um núcleo.

Observação- A execução do segmento não envolve a execução em vários núcleos. É assim que sequencia o conjunto de programas (Tópicos) no mesmo núcleo. No exemplo acima, vamos dizer à CPU como sequenciar e executar os dois segmentos no kernel dado.

De fato, Você pode ver o número de threads que estão sendo executados atualmente em sua máquina. No Windows: ir para O Gerente de Tarefas → O desempenho → da CPU.

Por que precisamos nos passar?? Por que não podemos processar um fio de cada vez e passar para o próximo?

As vezes, Um fio pode ser deixado pendurado, o que significa que você deveria estar inativo no momento. O melhor exemplo é a função time.sleep (), que não faz nada, mas esperar uma certa quantidade de tempo. Enquanto um fio está inativo / Enforcado, Podemos ir em frente e processar o outro segmento até que o segmento anterior seja ativado.. TLDR: Quando um fio está esperando, pode processar o outro segmento nesse meio tempo.

Isso é exatamente o que chamamos CComputação atual.

Um pequeno exemplo

Vamos explicar a rosca com um pequeno exemplo. Assista ao trecho de código abaixo.

#Parte Um do código
import time
print(1)
hora de dormir(10)
imprimir('Feito dormir)
imprimir(2)

#Parte Dois do código
imprimir(3)

Quando você executa todo o código como um único segmento, Código é executado passo a passo. Primeiro, A biblioteca é importada. Em seguida, '1' é impresso. Roscas dormem durante 10 segundos. O seguinte é impresso “2” seguido de “Pronto para dormir” e, finalmente, o “3”.

Saída-
1
Feito dormir
2
3

Agora vamos dizer que você está executando o código como dois tópicos. A primeira parte como fio e a segunda como fio. (Observação: por padrão, O código Python não é roscado; precisamos importar o fio biblioteca para fazê-lo.)

Primeiro, A biblioteca é importada e, em seguida, '1' é impresso. Agora o fio vai dormir. É aí que entra a rosca.

O kernel agora muda para o outro segmento.

Agora imprima '3'. Uma vez que todo o processo é realizado no segmento 2, O kernel agora retorna ao fio 1 (que ainda está suspenso).

Agora, após a duração do sono, '2' impresso.

Então a saída será

Saída-
1
3
Feito dormir
2

Exemplo prático

Como sempre, um conceito só é claro quando explicamos com um exemplo do mundo real. Processos E / S são os que se beneficiam do segmento.

Digamos que você está assistindo Shawshank Redemption na Netflix. Agora duas coisas acontecem enquanto ele vê Andy Dufresne sofrer na cadeia: uma: o aplicativo obtém dados do servidor, dos: os dados obtidos são exibidos para você como um filme na tela.

Imagine qual seria a situação sem encar. Você teria que esperar o vídeo baixar de tempos em tempos, ver o segmento que foi obtido, esperar o próximo segmento para baixar, etc.

Graças ao fio, podemos dividir os dois processos em diferentes segmentos. Enquanto um segmento obtém dados (quer dizer, está em modo de sono / suspensão), o outro fio pode mostrar-lhe o desempenho incrível de Morgan Freeman.

Também é muito útil para você como cientista de dados. Por exemplo, quando você extrai dados de várias páginas da Web, você pode simplesmente implantá-los em vários segmentos e torná-lo mais rápido. Mesmo quando você envia os dados para um servidor, você pode fazer isso em vários segmentos, de modo que quando um fio está ocioso, outros podem ser ativados.

Um exemplo detalhado

Como dito antes, por padrão, O código Python não é fornecido com threads; precisamos importar a biblioteca de roscas para fazê-lo.

Dê uma olhada no código.

import threading
import time

def sleepy_man(Segundos):
    imprimir('Começando a dormir por dentro')
    hora de dormir(Segundos)
    imprimir('Acordei por dentro')

x = rosca. Fio(alvo = sleepy_man, argumentos = (1,))
x.start()
imprimir(threading.activeCount())
hora de dormir(1.2)
imprimir('Feito')

Se você executar o código acima, você vai ter o seguinte resultado.

Saída-
Começando a dormir dentro
2
Woke up inside
Done

Primeiro, deixe-me explicar o código passo a passo. Então vamos analisar a saída.

• Importe a biblioteca fio e clima. fio é a biblioteca que nos permitirá criar threads e clima é a biblioteca que contém a função do sono.
• A função hombre_soñoliento tomar em um argumento segundos. Primeira impressão 'Começando a dormir por dentro'. Então durma para o segundos segundos e depois imprimir "Acordei por dentro".
• Esta é a parte em que começamos a criar threads. Precisamos definir chamando a classe fio. Precisamos passar dois argumentos.: objetivo qual é o bloco de funções que precisa ser roscado, argumentos quais são os argumentos que devem ser passados para a função. Um objeto de rosca que agora está armazenado em x é devolvido.

x = rosca. Fio(alvo = sleepy_man, argumentos = (10,))

• Agora, depois de definir a classe thread, Precisamos chamar a função começar() Para começar a roscar

• Observação- Agora temos dois fios. Um segmento padrão para o programa e um
  Novo segmento que definimos. Por tanto, O número de roscas ativas é de dois.
• Portanto, A declaração deve imprimir '2'.

imprimir(threading.activeCount())

Agora vamos olhar para o fluxo de controle. Uma vez que você chama começar() método, atirar hombre_soñoliento () e funciona em um segmento separado. O programa principal também será executado em paralelo como outro segmento. O fluxo é mostrado na imagem abaixo.

Agora vamos aumentar o tempo em que o programa dorme dentro da função.

import threading
import time

def sleepy_man(Segundos):
    imprimir('Começando a dormir por dentro')
    hora de dormir(Segundos)
    imprimir('Acordei por dentro')

x = rosca. Fio(alvo = sleepy_man, argumentos = (4,))
x.start()
imprimir(threading.activeCount())
hora de dormir(1.2)
imprimir('Feito')

A saída é a seguinte:

Começando a dormir dentro
2
Done
Woke up inside

O fluxo é dado no diagrama abaixo:

Agora vamos apimentar um pouco as coisas.. Vamos executar um loop para que aciona vários segmentos.

import threading
import time

def sleepy_man(Segundos):
    imprimir(Começando a dormir dentro - Iteração {}'.formato(5-Segundos))
    hora de dormir(Segundos)
    imprimir('Acordei dentro - Iteração {}'.formato(5-Segundos))

para eu no alcance(3):
    x = rosca. Fio(alvo = sleepy_man, argumentos = (5-eu,))
    x.start()

imprimir('Roscas ativas- ', threading.activeCount())

Começando a dormir dentro - Iteração 0
Começando a dormir dentro - Iteração 1
Começando a dormir dentro - Iteração 2
Roscas ativas-  4
Acordei lá dentro - Iteração 2
Acordei lá dentro - Iteração 1
Acordei lá dentro - Iteração 0

Relacionado