Filetage en Python | Qu'est-ce que le threading en Python?

Partager sur Facebook
Partager sur Twitter
Partager sur lié
Partager sur télégramme
Partager sur WhatsApp

Contenu

Threading en Python: Rendez votre code plus intelligent

Python est génial et nous le savons. Mais, Pouvez-vous être assez intelligent dans les aspects de traitement? Le filetage montre la voie.

Qu’est-ce que le parallélisme ??

Les machines précédentes avaient un seul cœur à l’intérieur du processeur où tout le traitement avait lieu..

Pourquoi le nombre de cœurs est-il important? C’est parce que cela indique la capacité de la machine à gérer plusieurs choses.. Si tu as 16 noyaux, peut effectuer 16 Différentes opérations en même temps.

Supposons que vous souhaitiez effectuer 16 Différentes opérations de somme et supposons que chaque opération prenne 1 seconde. Sur une machine monocœur, Vous devez effectuer ces opérations une par une, ce qui signifie que 16 Les opérations d’ajout sont effectuées dans 16 secondes. À présent, sur un 16 noyaux, Vous pouvez implémenter le 16 Ajoutez des opérations sur chaque cœur en même temps et faites le travail sur 1 seconde. Il s'appelle Parallélisme.

Fil

Fil est un ensemble d’opérations qui doivent être exécutées. Le thread sera implémenté sur l’un des cœurs du processeur. Noter: 1 thread ne peut être implémenté que dans 1 coeur, Impossible de transférer / changement de dent

Déplions deux fils dans un noyau. Noter: Un noyau ne peut faire qu’une chose à la fois.

1d5wqvcsyf4f74mgt2g_k_g-8327670

Maintenant, nous pouvons traiter les deux threads comme nous le voulons.

Premier, Nous pouvons traiter la moitié du premier thread.

1i_fogu8psxcsklkalrapxg-6670733

La moitié du thread suivant peut maintenant être traitée.

1myabkoktklk8zsv-z_ddyw-6315981

La moitié restante des threads peut être traitée de la même manière.

1ly2quxkj5r45r50aeipz0g-9476205

Voici ce qu’est le filetage Voici comment nous exécutons différentes choses sur le même cœur de processeur. TLDR- Le threading concerne la façon dont nous gérons les threads dans un noyau.

Noter- L’exécution de thread n’implique pas l’exécution sur plusieurs cœurs. Voici comment séquencer l’ensemble des programmes (Bobine) dans le même noyau. Dans l'exemple ci-dessus, nous dirons au CPU comment séquencer et exécuter les deux threads dans le noyau donné.

En réalité, Vous pouvez voir le nombre de threads en cours d’exécution sur votre machine. En Windows: accédez au Gestionnaire des tâches → CPU → Performance.

Pourquoi avons-nous besoin de thread?? Pourquoi ne pouvons-nous pas traiter un thread à la fois et passer au suivant?

Parfois, Un fil peut être laissé en suspens, ce qui signifie que vous êtes censé être inactif à ce moment-là. Le meilleur exemple est la fonction time.sleep (), qui ne fait rien d’autre qu’attendre un certain temps. Lorsqu’un thread est inactif / Pendu, Nous pouvons continuer et traiter l’autre thread jusqu’à ce que le thread précédent soit activé.. TLDR: Lorsqu’un thread est en attente, peut traiter l’autre thread entre-temps.

C’est exactement ce que nous appelons CInformatique actuelle.

Un petit exemple

Expliquons le threading avec un petit exemple. Regardez l’extrait de code ci-dessous.

#Première partie du code
import time
print(1)
le sommeil de temps(10)
imprimer('Fini de dormir)
imprimer(2)

#Deuxième partie du code
imprimer(3)

Lorsque vous exécutez tout le code en tant que thread unique, Le code s’exécute pas à pas. Premier, La bibliothèque est importée. Ensuite, '1' est imprimé. Les fils se mettent en veille pendant 10 secondes. Ce qui suit est imprimé “2” suivi de “Prêt à dormir” et enfin le “3”.

Sortir-
1
Fini de dormir
2
3

Supposons maintenant que vous exécutiez le code sous forme de deux threads. La première partie comme fil et la seconde comme fil. (Noter: par défaut, Le code Python n’est pas threadé; Nous devons importer le fil pour le faire.)

Premier, La bibliothèque est importée, puis '1' est imprimé. Maintenant, le fil se met en veille. C’est là que le filetage entre en jeu.

1Z6K2rdchniExyauc9MR4HA-8942500

Le noyau passe maintenant à l’autre thread.

1cy3UH65NBL8WNWWDdiHDMXQ-7134652

Maintenant, imprimez '3'. Puisque l’ensemble du processus est effectué sur le thread 2, Le noyau retourne maintenant au thread 1 (qui est toujours suspendu).

1uxcednvax6f506e3ht-fpq-6985366

À présent, après le sommeil, '2' imprimé.

Ensuite, la sortie sera

Sortir-
1
3
Fini de dormir
2

Exemple pratique

Comme toujours, Un concept n’est clair que lorsque nous l’expliquons avec un exemple réel.. Les processus de E / Ce sont les S qui bénéficient du fil.

Disons que vous regardez Shawshank Redemption sur Netflix. Maintenant, deux choses se produisent alors qu’il regarde Andy Dufresne souffrir en prison.: ongle: L’application obtient des données du serveur, De: Les données obtenues vous sont affichées sous forme de film à l’écran.

1g8rkyd8cytziwiazj0ka_q-5516699

Imaginez quelle serait la situation sans fil. Vous devrez attendre que la vidéo soit téléchargée de temps en temps, Voir le segment que vous avez obtenu, Attendez le téléchargement du segment suivant, etc.

Merci au fil, Nous pouvons diviser les deux processus en différents sous-processus. Lorsqu’un thread obtient des données (c'est-à-dire, est en mode veille / suspension), l’autre fil peut vous montrer l’incroyable performance de Morgan Freeman.

Il est également très utile pour vous en tant que data scientist. Par exemple, Lorsque vous extrayez des données de plusieurs pages Web, Vous pouvez simplement les déployer sur plusieurs threads et le faire plus rapidement. Même lorsque vous envoyez les données à un serveur, Vous pouvez le faire sur plusieurs threads, de sorte que lorsqu’un thread est inactif, D’autres peuvent être activés.

Un exemple détaillé

Comme dit précédemment, par défaut, Le code Python n’est pas threadé; Nous devons importer la bibliothèque de threads pour le faire.

Jetez un coup d’œil au code.

import threading
import time

def sleepy_man(Secs):
    imprimer(« Commencer à dormir à l’intérieur »)
    le sommeil de temps(Secs)
    imprimer(« Je me suis réveillé à l’intérieur »)

x = filetage. Fil(cible = sleepy_man, arguments = (1,))
x.start()
imprimer(threading.activeCount())
le sommeil de temps(1.2)
imprimer(« Terminé »)

Si vous exécutez le code ci-dessus, Vous obtiendrez le résultat suivant.

Sortir-
Commencer à dormir à l’intérieur
2
Woke up inside
Done

Premier, Laissez-moi vous expliquer le code étape par étape. Ensuite, nous analyserons la sortie.

  • Importer la bibliothèque fil Oui conditions météorologiques. fil C’est la bibliothèque qui nous permettra de créer des threads et conditions météorologiques est la bibliothèque qui contient la fonction sleep.
  • La fonction sleepy_man Argumenter secondes. Première impression 'Commencer à dormir à l’intérieur'. Puis dormez près de la secondes secondes, puis imprimez « Je me suis réveillé à l’intérieur ».
  • C’est la partie où nous commençons à créer des fils. Nous devons définir en appelant la classe fil. Nous devons passer deux arguments: objectif Quel est le bloc de fonctions qui doit être threadé, arguments Quels sont les arguments à passer à la fonction. Un objet thread est renvoyé qui est maintenant stocké dans x.
x = filetage. Fil(cible = sleepy_man, arguments = (10,))
  • À présent, Après avoir défini la classe de thread, Nous devons appeler la fonction début() Pour démarrer le threading
  • Noter- Maintenant, nous avons deux fils. Un thread par défaut pour le programme et un
    Nouveau fil que nous définissons. Pourtant, Le nombre de threads actifs est de deux.
  • Donc, La déclaration doit porter l’inscription « 2 ».
imprimer(threading.activeCount())

Regardons maintenant le flux de contrôle. Une fois que vous appelez début() méthode, tirer sleepy_man () et s’exécute sur un thread séparé. Le programme principal fonctionnera également en parallèle comme un autre thread. Le flux est montré dans l’image ci-dessous.

45642capture d’écran202021-04-2020at205-57-3920pm-9816829

Maintenant, augmentons le temps pendant lequel le programme dort dans la fonction.

import threading
import time

def sleepy_man(Secs):
    imprimer(« Commencer à dormir à l’intérieur »)
    le sommeil de temps(Secs)
    imprimer(« Je me suis réveillé à l’intérieur »)

x = filetage. Fil(cible = sleepy_man, arguments = (4,))
x.start()
imprimer(threading.activeCount())
le sommeil de temps(1.2)
imprimer(« Terminé »)

La sortie est la suivante:

Commencer à dormir à l’intérieur
2
Done
Woke up inside

Le débit est donné dans le schéma ci-dessous:

22165capture d’écran202021-04-2020at206-02-3120pm-3942363

Maintenant, pimentons un peu les choses.. Exécutons une boucle for qui déclenche plusieurs threads.

import threading
import time

def sleepy_man(Secs):
    imprimer(« Commencer à dormir à l’intérieur - Itération {}'.format(5-Secs))
    le sommeil de temps(Secs)
    imprimer(« Je me suis réveillé à l’intérieur - Itération {}'.format(5-Secs))

pour moi à portée(3):
    x = filetage. Fil(cible = sleepy_man, arguments = (5-je,))
    x.start()

imprimer('Threads actifs- ', threading.activeCount())

A chaque itération, Nous activons un fil de discussion. Notez que nous passons les arguments 5, 4, 3 une 1S t, 2Dakota du nord, Oui 3rd itération respectivement. Donc, la sleepy_man () Dormir 5 secondes, 4 secondes et 3 secondes respectivement.

Donc, La sortie est comme indiqué:

Commencer à dormir à l’intérieur - Itération 0
Commencer à dormir à l’intérieur - Itération 1
Commencer à dormir à l’intérieur - Itération 2
Threads actifs-  4
Réveillé à l’intérieur - Itération 2
Réveillé à l’intérieur - Itération 1
Réveillé à l’intérieur - Itération 0

Donc, Nous avons vu comment plusieurs threads peuvent être définis et activés, ce qui garantit un meilleur mode de traitement, ce qui est très essentiel aux opérations de E / S lourd.

Les médias présentés dans cet article ne sont pas la propriété de DataPeaker et sont utilisés à la discrétion de l'auteur.

Abonnez-vous à notre newsletter

Nous ne vous enverrons pas de courrier SPAM. Nous le détestons autant que vous.