ghid definitiv: Threading in Python

dacă abia începeți în Python și doriți să aflați mai multe, luați DataCamp Introducere în știința datelor în Python curs.

Introducere

Filetare vă permite să aveți diferite părți ale procesului rula simultan (Sursa: RealPython). Aceste părți diferite sunt de obicei individuale și au o unitate separată de execuție aparținând aceluiași proces., Procesul nu este altceva decât un program care rulează care are unități individuale care pot fi rulate simultan. De exemplu, un browser web ar putea fi un proces, o aplicație care rulează mai multe camere simultan ar putea fi un proces; un joc video este un alt exemplu de proces.

în interiorul unui proces vine conceptul de filetare multiplă sau cunoscut în mod obișnuit ca multi-threading, unde mai multe fire lucrează împreună pentru a atinge un obiectiv comun. Cel mai important beneficiu al utilizării firelor este că vă permite să rulați programul în paralel.,să înțelegem conceptul de filetare cu ajutorul unui exemplu. Imaginați-vă că aveți o aplicație care contează numărul de mașini care intră și ies din parcarea mall-ului. Aparatul dvs. are diferite camere care monitorizează intrarea și ieșirea care se conectează la un dispozitiv central. Fiecare cameră va avea un algoritm pentru a monitoriza fluxul de mașini, care va aparține aceluiași proces sau program. Cu toate acestea, fiecare cameră, împreună cu algoritmul pe care este rulat, ar putea face parte dintr-un fir separat., Nu numai asta, dar chiar și cadrele citite de la aparatul foto și algoritmul care prezice pe cadre ar putea fi, de asemenea, două fire separate.un alt exemplu ar putea fi un joc video în care procesul trebuie să ruleze sarcinile în paralel, cum ar fi grafica, interacțiunea cu utilizatorul și crearea de rețele (în timp ce jucați jocuri multiplayer), deoarece trebuie să fie receptiv în orice moment. Și pentru a realiza acest lucru, trebuie să utilizeze conceptul de multi-threading, unde fiecare fir ar fi responsabil pentru rularea fiecărei sarcini independente și individuale.,

un fir are fluxul său de execuție, ceea ce înseamnă că procesul va avea mai multe lucruri se întâmplă la un moment dat.

este important să rețineți că fiecare proces are cel puțin un fir, și care se numește main thread. Dacă programul dvs. nu are niciun fir definit, atunci acesta va avea cel puțin firul principal, adică procesul în sine.dacă te uiți la diagrama de mai sus, există un proces care constă din firul principal format din variabile globale și trei fire diferite t1, t2 și T3. Fiecare fir are variabilele sale locale și fluxul de execuție a codului., Firele împărtășesc, în general, resursele procesului, cum ar fi resursele disponibile pentru firul principal vor fi, de asemenea, împărțite între cele trei fire t1, t2 și T3. Toate firele vor avea acces la variabilele globale în timp ce au propriile lor variabile locale.,

Există diferite tipuri de fire:

• Kernel thread
• Utilizatorul fir
• Combinație de kernel si utilizator fir

Acum să ne uităm la unele dintre avantajele de a avea filetare în program:

• Multi-threading permite programul pentru a accelera executarea, cu condiția ca acesta are mai multe Procesoare.de asemenea, vă permite să efectuați alte sarcini în timp ce operațiile I/O sunt efectuate cu ajutorul mai multor fire sau chiar a firului principal împreună cu un singur fir., De exemplu, viteza cu care cadrele din cameră sunt citite și deduse de algoritm va fi gestionată de diferite fire. Prin urmare, algoritmul nu va trebui să aștepte introducerea cadrului, iar partea de citire a cadrului nu va trebui să aștepte finalizarea execuției algoritmului pentru a putea citi următorul cadru.

• firele din cadrul aceluiași proces pot partaja memoria și resursele firului principal.,nu uitați că Python funcționează pe baza implementării CPython, care limitează un singur fir pentru a fi rulat la un moment dat, prin urmare; filetarea poate să nu accelereze toate sarcinile. Iar motivul esențial din spatele acestui lucru este global interpret Lock (GIL).dacă doriți să aflați despre GIL, atunci nu ezitați să consultați acest tutorial.dacă sunteți în căutarea accelerării sarcinii intensive a procesorului, este posibil ca filetarea să nu fie cea mai bună soluție pentru dvs. În astfel de cazuri, multi-procesarea este considerată utilă.,pentru a executa un program care cuprinde diferite fire, este nevoie pentru a comuta rapid peste fire; prin urmare, Programarea trebuie să fie luate de îngrijire în programe în cazul în care aveți o mulțime de fire.partajarea resurselor poate fi, de asemenea, o problemă, deoarece toate firele împărtășesc aceleași resurse și memorie ale variabilelor globale. Prin urmare, operațiunile efectuate într-un fir ar putea provoca o eroare de memorie pentru un alt fir, sau celălalt fir ar putea să nu obțină memoria să-și îndeplinească sarcina.,

Threading în Python

• în Python, modulul threading este un modul încorporat care este cunoscut sub numele de threading și poate fi importat direct.deoarece aproape totul în Python este reprezentat ca un obiect, threading este, de asemenea, un obiect în Python. Un fir este capabil de

  • care deține date,
  • stocate în structuri de date, cum ar fi Dicționare, liste, seturi, etc.
  • poate fi trecut ca un parametru la o funcție.

• un fir poate fi, de asemenea, executat ca un proces.,

• un fir în Python poate avea diferite stări cum ar fi:

  • așteptați,
  • blocat.

Să învățăm acum cum puteți implementa filetarea în Python.

Ață de modul în Python3

Rețineți că Python3 este compatibil cu thread module, care există în Python2.7. În Python3, acesta poate fi importat ca _thread modul. Deci, să luăm un exemplu și să înțelegem modulul _thread.,

import _thread #thread module importedimport time #time module

haideți Să definim o funcție numită thread_delay, care va avea doi parametri ca o intrare, de exemplu, numele de fir și întârziere. În interiorul această funcție, veți:

• Defini un contor cu zero,
• Atunci va bucla în jurul valorii de cu o buclă în timp ce, care va rula de trei ori,
• în buclă în timp ce, te va pune time.sleep() pentru a adăuga o întârziere, această întârziere va fi util pentru a înțelege executarea de fir., Această întârziere va fi în câteva secunde,
• apoi veți crește contorul cu 1,
• pentru a vedea dacă execuția firului dvs. merge fără probleme, veți imprima numele firului și ora la care este executat firul.

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

Acum pentru a adăuga la thread funcționalitate pe funcția de mai sus sau pentru a rula funcția de mai sus in thread, ar trebui să utilizați start_new_thread metoda, care este în interiorul _thread module.

Să vedem docstring-ul metodei start_new_thread.,

?_thread.start_new_thread

Să treacă în funcția thread_delay fără paranteze și două argumente, și anume, firul numele și întârziere (pentru a vizualiza fir de execuție deoarece este foarte rapid).

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 3))

Din cele de mai sus de ieșire, puteți vedea că firul t1 începe să execute primul., Între timp, fir t2 așteaptă, deoarece nu există o 3 secunde întârziere, și de îndată ce această întârziere este terminat, fir t2 este executat, și, de asemenea, întârziere pentru fir t1 este doar 1 secundă.

acum Să modificați întârzierea de t2 la 5 secunde, care va începe t2 dupa t1 s-ar fi terminat de executare deoarece t1 va avea doar 3 secunde pentru a finaliza executarea acestuia.,

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 5))

punere în Aplicare filetare folosind modulul Threading

Să folosim acelasi exemplu ca te-ai folosit mai sus, dar de această dată va folosi threading module în loc de _thread module.

import threadingimport time

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

în threading module este un Thread clasa, care este un spirit similar cu start_new_thread funcția _thread module.,

Să ne uităm la docstring de Thread clasa, care are mai mulți parametri, cum ar fi grupul țintă (cum ar fi o funcție), args, etc.

?threading.Thread

În clasa Fir constructor, va trece în funcția țintă thread_delay și argumentele de această funcție.,

t1 = threading.Thread(target=thread_delay, args=('t1', 1))t2 = threading.Thread(target=thread_delay, args=('t2', 3))

În modulul threading, în scopul de a rula sau executa fir, puteți face uz de start() metoda, care pur și simplu responsabil pentru rularea filetului.

?t1.start

t1.start()t2.start()

Veți folosi, de asemenea, join metoda, ceea ce înseamnă că așteptați până când toate fir de execuție este completă., Deci, indiferent de codul pe care l-ați scris după metoda join va fi executat numai după terminarea acestor fire.

?t1.join

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Acum să se calculeze volumul cubului și pătrat folosind filetare concept, care este destul de drept înainte.

def volume_cube(a): print ("Volume of Cube:", a*a*a)

def volume_square(a): print ("Volume of Square:", a*a)

t1 = threading.Thread(target=volume_cube, args=(2))t2 = threading.Thread(target=volume_square, args=(3))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Așteaptă; ce? De îndată ce ați executat metoda de pornire, a rezultat o eroare., Asta este pentru că args parametru se așteaptă un tuplu, iar de la volume_cube și volume_square așteaptă un singur parametru, prin urmare, aveți nevoie pentru a pune o virgulă în args parametru după specificarea primul argument al funcțiilor.

t1 = threading.Thread(target=volume_cube, args=(2,))t2 = threading.Thread(target=volume_square, args=(3,))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Volume of Cube: 8Volume of Square: 9Thread execution is complete!

Să învețe să folosească filetare ca o subclasă.,

Filetare ca o sub-clasă

În această secțiune, veți învăța cum să creați sub-clasa de clasa fir, care este disponibil în modulul threading, și apoi a crea thread cazuri t1 și t2 din această clasă.

ați folosi aceeași funcție thread_delay și aici.

Acum, haideți să înțeleagă codul de mai sus pas cu pas:

• – Ați definit o clasa ca DataCampThread, iar în clasa argument, ai trecut în threading.Thread clasa., Motivul pentru care faceți acest lucru este că doriți să creați o sub-clasă din modulul de filetare. Făcând acest lucru vă permite să utilizați toate metodele disponibile în clasa threading.Thread similar cu conceptul de moștenire.

• apoi, ați definit metoda init a clasei DataCampThread și ați trecut în funcție împreună cu întârzierea. Init este un constructor similare la parametrii ai trecut de la threading.Thread clasa, aici ar fi trecerea la DataCampThread clasa.,

• apoi inițializați metoda de inițializare a filetului principal.Clasa Thread și apoi echivala numele și întârziere.

• apoi, definiți run metoda, amintesc aici ai definit start metodă, care, practic, sub capota apeluri run metoda. Deoarece ați moștenit clasa principală, vi se permite să faceți modificări la metoda run., Prin urmare, atunci când apelați metoda start, orice modificări veți face în metoda run vor fi reflectate acum.

concluzie

felicitări pentru finalizarea tutorialului.acest tutorial a fost o introducere de bază pentru filetarea în python. Cu toate acestea, filetarea este un subiect foarte vast și vital, iar unele concepte ar fi putut fi lăsate neexplorate. Simțiți-vă liber să vă uitați la mai multe metode de filetare, cum ar fi numărul activ, firul curent etc.

dacă doriți să aflați mai multe, consultați și paralelismul bazat pe fir al lui Python.,

dacă abia începeți în Python și doriți să aflați mai multe, luați cursul Introducere DataCamp în știința datelor în Python.