Une compréhension simple du multi-threading Python et des verrous de thread (code)

Cet article vous apporte une compréhension simple (code) du multithreading Python et des verrous de thread. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Le module de thread multi-thread crée des threads, crée sa propre classe de thread, la communication des threads, la synchronisation des threads, la méthode d'exclusion mutuelle, le verrouillage des threads@besoin de savoir ! ! !

Multi-threading

Qu'est-ce qu'un fil de discussion ?

Les threads sont également une méthode de programmation multitâche qui peut utiliser les ressources multicœurs de l'ordinateur pour compléter l'exécution simultanée de programmes.

Les threads sont également appelés processus légers

Caractéristiques des threads

Les threads sont la plus petite unité d'allocation multicœur d'un ordinateur

Un processus peut contenir plusieurs threads

Un thread est également un processus en cours d'exécution, consommant des ressources informatiques. Plusieurs threads partagent les ressources et l'espace du processus

La création et la suppression de threads consomment beaucoup moins de ressources que le processus

L'exécution de plusieurs threads n'interfère pas les uns avec les autres

Les threads ont également leurs propres attributs uniques, tels que l'ID du jeu d'instructions

le module de thread crée des threads

t =threading.Thread( )

name : nom du thread, valeur par défaut si vide, Tread-1, Tread-2, Tread-3

target : fonction du thread

args : element Group, transmettre les paramètres à la fonction thread en fonction de la position

kwargs : dictionnaire, transmettre les paramètres à la fonction country en fonction de la valeur clé

Fonction : Créer un objet thread

Paramètres

t.start() : Démarrez le thread et exécutez automatiquement la fonction de thread

t.join([timeout]) : Recyclez le processus

t.is_alive( ) : Afficher l'état du fil

t.name() : Afficher le nom du fil

t.setName() : Définir le nom du fil

Attribut t.daemon : Par par défaut, le thread principal se ferme et n'affecte pas la poursuite de l'exécution du thread de branche. Si défini. Si True, le thread de branche se termine avec le thread principal

t.daemon = True

t.setDaemon. (Ture)

Définir la méthode

#!/usr/bin/env python3
from threading import Thread
from time import sleep
import os
# 创建线程函数
def music():
    sleep(2)
    print("分支线程")

t = Thread(target = music)
# t.start()   # ******************************
print("主线程结束---------")

'''没有设置的打印结果
主线程结束---------
分支线程
'''

'''设置为True打印结果
主线程结束---------
'''

threading.currentThread : obtenir l'objet de thread actuel

@Le code ici indique que les sous-threads partagent des variables dans le même processus

#!/usr/bin/env python3
from threading import Thread
from time import sleep
import os

# Créer une fonction de thread
def music( ):
global a
print("a=",a)
a = 10000
pour i in range(5):
sleep(1)
print("1212 ")

a = 1
t = Thread(target = music )
t.start()
t.join()
print("a du fil principal = ",a) Créez votre propre classe de thread

Point d'inspection : utilisation des classes, Appelez la méthode __init__ de la classe parent, les fonctions *passage de paramètres et **passage de paramètres

from threading import Thread
import time

class MyThread(Thread):
    name1 = 'MyThread-1'
    def __init__(self,target,args=(), kwargs={}, name = 'MyThread-1'):
        super().__init__()
        self.name = name
        self.target = target
        self.args = args
        self.kwargs = kwargs
    def run(self):
        self.target(*self.args,**self.kwargs)

def player(song,sec):
    for i in range(2):
        print("播放 %s：%s"%(song,time.ctime()))
        time.sleep(sec)

t =MyThread(target = player, args = ('亮亮',2))

t.start()
t.join()

Communication par thread

méthode de communication : en raison du fait que plusieurs threads partagent l'espace mémoire du processus, la communication entre les threads peut donc être complétée à l'aide de variables globales

Remarque : Lors de l'utilisation de variables globales entre les threads, un mécanisme d'exclusion mutuelle de synchronisation est souvent nécessaire pour assurer la sécurité de la communication

Méthode d'exclusion mutuelle de synchronisation des threads

event

e = threading.Event () : Créer un objet événement

e.wait([timeout]) : Définir le statut S'il a été défini, alors cette fonction bloquera, le délai d'attente est le délai d'attente

e.set. : Changez e dans l'état de réglage

e.clear : Supprimez l'état de réglage

import threading
from time import sleep

def fun1():
    print("bar拜山头")
    global s
    s = "天王盖地虎"

def fun2():
    sleep(4)
    global s
    print("我把限制解除了")
    e.set()     # 解除限制，释放资源

def fun3():
    e.wait() # 检测限制
    print("说出口令")
    global s
    if s == "天王盖地虎":
        print("宝塔镇河妖，自己人")
    else:
        print("打死他")
    s = "哈哈哈哈哈哈"

# 创建同步互斥对象
e = threading.Event()
# 创建新线程
f1 = threading.Thread(target = fun1)
f3 = threading.Thread(target = fun3)
f2 = threading.Thread(target = fun2)
# 开启线程
f1.start()
f3.start()
f2.start()
#准备回收
f1.join()
f3.join()
f2.join()

Verrouillage du fil

lock = threading .Lock() : Créer un objet de verrouillage

lock.acquire() : Lock

lock.release() : Déverrouiller

Vous pouvez également utiliser with pour verrouiller

1 with lock:
2     ...
3     ...

Besoin de savoir ! ! !

Problèmes GIL avec les threads Python (interpréteur global) :

python----> prend en charge le multi-threading----> problème d'exclusion mutuelle de synchronisation----> Solution de verrouillage---->Super verrouillage (verrouiller l'interpréteur)---->L'interpréteur ne peut interpréter qu'un seul thread à la fois--->Conduisant à une faible efficacité

Conséquences :

Un interpréteur ne peut interpréter et exécuter qu'un seul thread à la fois, donc l'efficacité du thread Python est faible. Cependant, lorsqu'il rencontre un blocage d'E/S, le thread abandonnera activement l'interpréteur, le thread Python est donc plus approprié. Concurrence du programme d'E/S à haute latence

Solution

Essayez d'utiliser des processus pour compléter la concurrence (identique à ce qui n'est pas mentionné)

Il n'est pas approprié d'utiliser un interpréteur C (utilisez C#, JAVA)

Essayez d'utiliser Une combinaison de plusieurs solutions est utilisée pour effectuer des opérations simultanées, et les threads sont utilisés comme IO à haute latence

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!