Qu’est-ce que la synchronisation des threads Python ? Comprendre le module de thread Python dans un article

Si plusieurs threads modifient conjointement certaines données, des résultats imprévisibles peuvent se produire. Afin de garantir l'exactitude des données, plusieurs threads doivent être synchronisés.

L'utilisation des fonctions Lock et Rlock de l'objet Thread peut réaliser une synchronisation des threads simple. Les deux objets ont des méthodes d'acquisition et de libération, pour les données qui ne doivent autoriser qu'un seul thread à fonctionner à la fois. time , son fonctionnement peut être placé entre les méthodes d'acquisition et de libération. Comme suit :

L'avantage du multithreading est qu'il peut exécuter plusieurs tâches en même temps (du moins c'est ce que l'on ressent). Mais lorsque les threads doivent partager des données, des problèmes de désynchronisation des données peuvent survenir.

Considérez cette situation : tous les éléments d'une liste sont à 0, le fil "set" change tous les éléments à 1 de l'arrière vers l'avant, et le fil "print" se charge de lire la liste d'avant en arrière et impression.

Ensuite, peut-être que lorsque le thread "set" commencera à changer, le thread "print" imprimera la liste et la sortie sera moitié 0 et moitié 1. C'est la désynchronisation des données. Pour éviter cette situation, le concept de serrures a été introduit.

Les serrures ont deux états : verrouillé et déverrouillé. Chaque fois qu'un thread tel que « set » veut accéder aux données partagées, il doit d'abord obtenir le verrou ; si un autre thread tel que « print » a déjà obtenu le verrou, laissez le thread « set » faire une pause, ce qui est un blocage synchrone ; jusqu'à ce que le fil " Imprimer " Une fois l'accès terminé et le verrou libéré, laissez le fil " défini " continuer.

Après un tel traitement, lors de l'impression de la liste, soit tous les 0, soit tous les 1 seront imprimés, et il n'y aura plus de scène embarrassante de moitiés de 0 et moitié de 1.

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import threading
import time
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print "Starting " + self.name
# 获得锁，成功获得锁定后返回True# 可选的timeout参数不填时将一直阻塞直到获得锁定
# 否则超时后将返回False
threadLock.acquire()
print_time(self.name, self.counter, 3)
# 释放锁
threadLock.release()
def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
threadLock = threading.Lock()
threads = []
# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 开启新线程
thread1.start()
thread2.start()
# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)
# 等待所有线程完成
for t in threads:
t.join()
print "Exiting Main Thread"

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!