Catalogue des articles

• Thread
• Multithreading

Cet article introduira Python Les bases du Multithreading dans les langages de programmation.C'est comme traiter plus,Le Multithreading est une façon de réaliser le multitâche.En Multithreading,Utiliser ThreadLe concept de.

Commençons par l'architecture informatiqueThreadLe concept de.

Thread

Dans le calcul,ProcessusEst une instance d'un programme d'ordinateur en cours d'exécution.Tout processus a 3 Éléments de base：

• Programme exécutable.
• Données d'association requises par le programme（Variables、Espace de travail、Tampons, etc）
• Contexte d'exécution du programme（État du processus）

ThreadEst l'entité dans le processus qui peut être programmée pour l'exécution.En outre,C'est possible sur le système d'exploitation（Système d'exploitation）Unit é de traitement minimale à exécuter dans.

En termes simples,ThreadEst une séquence d'instructions dans un programme qui peut être exécutée indépendamment d'autres codes.Par souci de simplicité,Vous pouvez supposer que le thread n'est qu'un sous - ensemble du processus！

Thread inBloc de contrôle du fil （TCB） Contient toutes ces informations：

• Identifiant du fil： Sera unique ID （TID） Assigner à chaque nouveau thread
• Pointeur de pile： Pointez vers la pile de Threads dans le processus.La pile contient des variables locales sous la portée du thread.
• Compteur de programmes： Un registre qui stocke l'adresse de l'instruction que le thread exécute actuellement.
• État du fil： Ça pourrait être en cours 、Prêt.、Attendez.、 Démarrer ou terminer .
• L'ensemble de registre du thread ： Registre assigné au thread pour le calcul .
• Pointeur de processus parent ： Bloc de contrôle de processus pointant vers le processus dans lequel le thread est situé （PCB） Pointeur vers.

Voir l'illustration ci - dessous pour la relation entre le processus et son thread ：

Multithreading

Plusieurs Threads peuvent exister dans un processus ,Parmi eux：

• Chaque fil contient son propre Ensemble de registresEtVariables locales（ Stocké dans la pile ）.
• Tous les Threads du processus sont partagés Variables globales（Stocké dans le tas） EtCode du programme.

Voir l'image ci - dessous pour voir comment plusieurs Threads existent en mémoire ：

InPythonMoyenne,Thread Le module offre un API, Utilisé pour générer plusieurs Threads dans un programme .

Prenons un exemple simple d'utilisation d'un module thread ：

import threading
def print_cube(num):
""" Fonction utilisée pour imprimer un cube d'un nombre donné """
print("Cube: {}".format(num * num * num))
def print_square(num):
""" La fonction imprime le carré d'une valeur donnée """
print("Square: {}".format(num * num))
if __name__ == "__main__":
# Créer un thread
t1 = threading.Thread(target=print_square, args=(10,))
t2 = threading.Thread(target=print_cube, args=(10,))
# Démarrer le thread1
t1.start()
# Démarrer le thread2
t2.start()
# Fil d'attente1 Mise en œuvre intégrale
t1.join()
# Fil d'attente2 Mise en œuvre intégrale
t2.join()
# Les deux Threads ont été entièrement exécutés
print("Done!")

Résultats des opérations：

Essayons de comprendre le code ci - dessus ：

• Pour importer un module thread ,Il nous faut：

  import threading
  

• Pour créer un nouveau thread ,Nous créons un Thread Objet de la classe. Il nécessite les paramètres suivants ：

  • Objectifs：La fonction à exécuter par le thread
  • args： Paramètres à passer à la fonction cible

  Dans l'exemple ci - dessus,,Nous avons créé2 Threads with Different Target functions ：

  t1 = threading.Thread(target=print_square, args=(10,))
  t2 = threading.Thread(target=print_cube, args=(10,))
  

• Pour démarrer le thread ,Nous utilisons Thread Classe start Méthodes.

  t1.start()
  t2.start()
  

• Une fois le thread lancé,Procédure actuelle（ Vous pouvez l'imaginer comme un fil principal ）Et il va continuer. Pour arrêter l'exécution du programme actuel ,Jusqu'à ce que le thread soit terminé,Nous utilisonsConnexionMéthodes.

  t1.join()
  t2.join()
  

  Donc,, Le programme actuel attendra d'abord t1 La fin de,Et attendez. t2 Terminé..Une fois terminé, Les autres déclarations du programme actuel seront exécutées .

Considérez le graphique ci - dessous., Pour mieux comprendre le fonctionnement de la procédure décrite ci - dessus ：

Considérez ce qui suitpythonProcédure, Où nous imprimons le nom du thread et le processus correspondant pour chaque tâche ：

import threading
import os
def task1():
print("Mission1Assigner au thread: {}".format(threading.current_thread().name))
print("Exécuter la tâche1ProcessusID: {}".format(os.getpid()))
def task2():
print("Mission2Assigner au thread: {}".format(threading.current_thread().name))
print("Exécuter la tâche2ProcessusID: {}".format(os.getpid()))
if __name__ == "__main__":
# Imprimer le processus actuel ID
print(" Processus d'exécution du programme principal ID: {}".format(os.getpid()))
# Imprimer le nom du fil principal
print("Nom du fil principal: {}".format(threading.current_thread().name))
# Créer un thread
t1 = threading.Thread(target=task1, name='t1')
t2 = threading.Thread(target=task2, name='t2')
# Démarrer le thread
t1.start()
t2.start()
# Attendre que tous les Threads soient terminés
t1.join()
t2.join()

Résultats des opérations：

Essayons de comprendre le code ci - dessus ：

• Nous utilisons os.getpid（） Fonction pour obtenir ID.

  print(" Processus d'exécution du programme principal ID: {}".format(os.getpid()))
  

  Il ressort clairement des résultats , Processus pour tous les Threads ID Reste le même..

• Nous utilisonsthreading.main_thread（） Fonction pour obtenir l'objet thread principal .Dans des conditions normales, Le fil principal est le démarrage Python Le fil de l'interpréteur .Objet thread name Propriété utilisée pour obtenir le nom du thread .

  print("Nom du fil principal: {}".format(threading.main_thread().name))
  

• Nous utilisons threading.current_thread（） Fonction pour obtenir l'objet thread actuel .

  print("Mission1Fils assignés: {}".format(threading.current_thread().name))
  

La figure ci - dessous illustre les concepts ci - dessus ：