Comment utiliser le module de thread pour la gestion multi-thread dans Python 2.x

Comment utiliser le module de threading pour la gestion multi-thread dans Python 2.x

En Python, le multi-threading peut être utilisé pour effectuer plusieurs tâches simultanément dans le même programme, améliorant ainsi l'efficacité d'exécution du programme. Le module threading est un module fourni par Python pour gérer les threads. En utilisant le module threading, nous pouvons facilement créer, contrôler et gérer plusieurs threads.

Cet article expliquera comment utiliser le module de threading pour la gestion multi-thread dans Python 2.x et donnera des exemples de code pertinents. Tout d'abord, nous devons importer le module threading :

import threading

Ensuite, nous pouvons utiliser la classe Thread du module threading pour créer un nouveau thread. Il existe deux manières de créer un thread : l'une consiste à instancier directement la classe Thread et l'autre à hériter de la classe Thread et à remplacer la méthode run(). Ces deux méthodes sont présentées ci-dessous.

Méthode 1 : Instancier directement la classe Thread

# 创建线程的函数
def worker():
    print('Worker')

# 创建线程实例
t = threading.Thread(target=worker)

# 启动线程
t.start()

# 等待线程结束
t.join()

Dans l'exemple ci-dessus, nous définissons d'abord une fonction worker(), qui servira de tâche à exécuter par le thread. Ensuite, nous avons instancié un objet Thread t et spécifié la fonction d'exécution du thread comme worker() via le paramètre target. Ensuite, nous appelons la méthode t.start() pour démarrer le thread, et le thread commencera à exécuter les tâches dans la fonction worker().

Méthode 2 : hériter de la classe Thread et remplacer la méthode run()

# 创建继承自 Thread 的子类
class MyThread(threading.Thread):
    def run(self):
        print('Worker')

# 创建线程实例
t = MyThread()

# 启动线程
t.start()

# 等待线程结束
t.join()

Dans cette méthode, nous devons créer une sous-classe qui hérite de la classe Thread et remplacer la méthode run() dans la sous-classe. Les tâches d'exécution du thread sont définies dans la méthode run(). Ensuite, nous instancions un objet de sous-classe t et utilisons cet objet pour démarrer le thread. Comme pour la méthode 1, nous pouvons également attendre la fin de l’exécution du thread via t.join().

Lors de l'utilisation du module threading pour la gestion multi-thread, nous rencontrons souvent des situations où la communication de données doit être effectuée entre les threads. Dans le module de threading, certaines primitives de synchronisation sont fournies pour nous aider à réaliser le partage de données et la communication entre les threads.

Une primitive de synchronisation couramment utilisée est un mutex (Mutex). Les verrous mutex peuvent être utilisés pour garantir qu'un seul thread peut accéder à une ressource partagée en même temps. Dans le module threading, nous pouvons utiliser la classe Lock pour créer un mutex.

# 创建互斥锁
lock = threading.Lock()

# 定义一个共享数据
shared_data = []

# 创建线程的函数
def worker():
    # 加锁
    lock.acquire()
    try:
        # 对共享数据进行操作
        shared_data.append('Hello')
        shared_data.append('World')
        print(shared_data)
    finally:
        # 释放锁
        lock.release()

# 创建线程实例
t1 = threading.Thread(target=worker)
t2 = threading.Thread(target=worker)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

Dans l'exemple ci-dessus, nous créons d'abord un verrou mutex. Ensuite, dans la fonction worker(), nous appelons d'abord la méthode lock.acquire() pour acquérir le verrou, puis opérons sur les données partagées shared_data, et enfin appelons la méthode lock.release() pour libérer le verrou. Grâce à l'utilisation de verrous mutex, nous pouvons garantir qu'un seul thread peut exploiter shared_data en même temps et éviter les problèmes de concurrence de données causés par plusieurs threads accédant aux données partagées en même temps.

En plus des verrous mutex, le module de threading fournit également d'autres primitives de synchronisation, telles qu'un sémaphore, une variable de condition, un événement, etc. En appliquant correctement ces primitives de synchronisation, nous pouvons réaliser une communication et une coordination inter-thread complexes.

Pour résumer, il est très simple d'utiliser le module threading pour la gestion multi-thread en Python 2.x. Nous pouvons utiliser la classe Thread du module threading pour créer un thread et définir les tâches d'exécution du thread de deux manières (en instanciant directement la classe Thread et en héritant de la classe Thread). Dans le même temps, nous pouvons également réaliser le partage de données et la communication entre les threads via des primitives de synchronisation telles que les verrous mutex. En maîtrisant ces connaissances, nous pouvons utiliser le multi-threading de manière flexible pour améliorer l'efficacité de fonctionnement du programme.

Référence :

1. Module de threading de la documentation officielle Python : https://docs.python.org/2/library/threading.html

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!