Cet article est basé sur【Mo FanPython】Threading Apprendre le Multithreading PythonUn enregistrement vidéo de l'étude.
Mo FanPythonSi beau, si mignon.

Table des matières

• Ajouter un fil
• joinFonction——Fusionner
• QueueFonction——Transfert de valeur
• Verrouillage du fil

Nom de la fonctionFonctionthreading.active_count()Combien de Threads sont actuellement actifsthreading.enumerate()Quels sont les Threads actifsthreading.current_thread()Quel thread est en cours d'exécution

Ajouter un fil

import threading
def thread_job():
print('This is an added Thread, number id %s' % threading.current_thread())
def main():
added_thread = threading.Thread(target=thread_job) # Créer un thread
added_thread.start() # Démarrer le thread
if __name__ == '__main__':
main()

joinFonction——Fusionner

Pensez d'abord à quelques questions ：

1. Comment réaliser la fusion d'un thread et d'un thread principal ？
2. S'il y a plus d'un thread, Je veux attendre la fin de tous les Threads avant de continuer ,Comment réaliser？

import threading
import time
def thread_job():
print('T1 start')
for i in range(10):
time.sleep(0.1)
print('T1 finish')
def t2_job():
print('T2 start')
print('T2 finish')
def main():
added_thread = threading.Thread(target=thread_job, name='T1')
thread2 = threading.Thread(target=t2_job)
added_thread.start()
thread2.start()
added_thread.join()
thread2.join()
print('all down!')
if __name__ == '__main__':
main()

QueueFonction——Transfert de valeur

Peut passer les paramètres dans le fil , Mais le thread ne peut pas avoir de valeur de retour .
Le but de l'exemple suivant est de data Toutes les valeurs de la liste sont au carré ：

import threading
import time
from queue import Queue
# Données de la liste à modifier 
data = [[1, 2, 3], [3, 4, 5], [4, 4, 4], [5, 5, 5]]
# Définir une fonction fonctionnelle , Carré les valeurs de la liste 
def job(l):
for i in range(len(l)):
l[i] = l[i]**2
return l
# Si vous n'avez pas besoin de Multithreading , Mise en œuvre de la manière suivante: 
def no_threading():
result = []
for d in data:
r = job(d)
result.append(r)
print(result)
def job2(l, q):
for i in range(len(l)):
l[i] = l[i]**2
q.put(l)
def multithreading():
q = Queue()
threads = []
# Démarrer le thread
for i in range(4):
t = threading.Thread(target=job2, args=(data[i], q))
t.start()
threads.append(t)
# Récupérer les fils
for thread in threads:
thread.join()
# Obtenir des données
results = []
for _ in range(4):
results.append(q.get())
print(results)
if __name__ == '__main__':
# no_threading()
multithreading()

Verrouillage du fil

import threading
def job1():
global A, lock
lock.acquire()
for i in range(10):
A += 1
print('job1', A)
lock.release()
def job2():
global A, lock
lock.acquire()
for i in range(10):
A += 10
print('job2', A)
lock.release()
if __name__ == '__main__':
A = 0
lock = threading.Lock()
t1 = threading.Thread(target=job1)
t2 = threading.Thread(target=job2)
t1.start()
t2.start()
t1.join()
t2.join()