Definitive Guide: Threading in Python (Magyar)

Ha még csak most kezded el a Python és szeretne többet megtudni, hogy DataCamp bevezetése Data Science in Python tanfolyam.

Bevezetés

a menetvágás lehetővé teszi a folyamat különböző részeinek egyidejű futtatását (forrás: RealPython). Ezek a különböző részek általában egyediek, és egy külön végrehajtási egységgel rendelkeznek, amely ugyanahhoz a folyamathoz tartozik., A folyamat nem más, mint egy futó program, amely egyedi egységekkel rendelkezik, amelyek egyidejűleg futtathatók. Például egy webböngésző lehet egy folyamat, egy alkalmazás, amely egyszerre több kamerát futtat, folyamat lehet; A videojáték egy másik példa egy folyamatra.

egy folyamat belsejében a többszörös menetvágás vagy közismert nevén multi-threading fogalma jön létre, ahol több szál működik együtt egy közös cél elérése érdekében. A szálak használatának legfontosabb előnye, hogy lehetővé teszi a program párhuzamos futtatását.,

értsük meg a menetvágás fogalmát egy példa segítségével. Képzeld el, hogy van egy alkalmazás, amely számolja az autók száma belépő és kilép a bevásárlóközpont parkolójában. A készülék különféle kamerákkal rendelkezik, amelyek figyelik a központi eszközhöz csatlakozó belépést és kijáratot. Minden kamerának van egy algoritmusa az autók áramlásának ellenőrzésére, amelyek ugyanahhoz a folyamathoz vagy programhoz tartoznak. Azonban minden kamera, az algoritmussal együtt, amelyen fut, egy külön szál része lehet., Nem csak ez, de még a kamerából leolvasott képkockák és a kereteken előrejelző algoritmus is két külön szál lehet.

egy másik példa lehet egy videojáték, amelyben a folyamatnak párhuzamosan kell futtatnia a feladatokat, mint például a grafika, a felhasználói interakció és a hálózatépítés (multiplayer játékok lejátszása közben), mert mindig reagálnia kell. Ehhez pedig ki kell használnia a multi-threading fogalmát, ahol minden szál felelős lenne minden független és egyedi feladat futtatásáért.,

egy szálnak megvan a végrehajtási áramlása, ami azt jelenti, hogy a folyamat egyszerre több dolog történik.

fontos megjegyezni, hogy minden folyamatnak legalább egy szála van, amelyet main thread – nak neveznek. Ha a programnak nincs meghatározott szála, akkor legalább a fő szál, azaz maga a folyamat lesz.

Ha megnézzük a fenti diagramot, van egy folyamat, amely a globális változókból és három különböző T1, t2 és t3 szálból álló fő szálból áll. Minden szál rendelkezik a helyi változókkal és a kód végrehajtásának áramlásával., A szálak általában megosztják a folyamat erőforrásait, mint például a fő szál rendelkezésére álló erőforrások is megosztásra kerülnek a három T1, t2 és t3 szál között. Az összes szál hozzáférhet a globális változókhoz, miközben saját helyi változókkal rendelkezik.,

vannak különböző típusú szálak:

• Kernel szál
• Felhasználói szál
• Kombinációja kernel, valamint a felhasználói szál

Most nézzünk néhány előnye, hogy threading a program:

• Multi-threading lehetővé teszi, hogy a program, hogy gyorsítsák fel a kivégzést, feltéve, hogy több Cpu.

• lehetővé teszi más feladatok elvégzését is, miközben az I/O műveleteket több szál vagy akár fő szál segítségével hajtják végre egyetlen szál mellett., Például azt a sebességet, amellyel a kamera képkockái olvashatók és következtethetők az algoritmus által, különböző szálak fogják kezelni. Ezért az algoritmusnak nem kell várnia a keret bevitelére, a keretolvasó résznek pedig nem kell várnia, amíg az algoritmus végrehajtása befejeződik, hogy képes legyen olvasni a következő keretet.

• ugyanazon folyamat szálai megoszthatják a fő szál memóriáját és erőforrásait.,

A Menetvágás kihívásai:

• ne feledje, hogy a Python a cpython implementáción alapul, amely egyszerre csak egy szál futtatását korlátozza; ezért a menetvágás nem gyorsíthatja fel az összes feladatot. Ennek alapvető oka a Global Interpreter Lock (GIL).

  Ha szeretne megtudni GIL, akkor nyugodtan nézd meg ezt a bemutatót.

• Ha a CPU-intenzív feladat felgyorsítását keresi, akkor a menetvágás nem feltétlenül a legjobb megoldás az Ön számára. Ilyen esetekben a többfeldolgozás hasznosnak tekinthető.,

• a különböző szálakból álló program végrehajtásához gyorsan át kell váltania a szálakat; ezért az ütemezést gondoskodni kell olyan programokban, ahol sok szál van.

• az erőforrás-megosztás is problémát jelenthet, mivel az összes szál azonos erőforrásokkal és memóriával rendelkezik a globális változókról. Ezért az egyik szálon végrehajtott műveletek Memóriahibát okozhatnak egy másik szál esetében, vagy a másik szál nem kapja meg a memóriát a feladat elvégzéséhez.,

Threading in Python

• Python, a threading modul egy beépített modul, amely az úgynevezett threading és közvetlenül importálható.

• mivel a Python szinte mindent objektumként ábrázol, a threading is egy objektum a Python-ban. A szál képes

  • adatok tárolására,
  • Adatstruktúrákban, például szótárakban, listákban, készletekben stb.
  • paraméterként átadható egy függvénynek.

• egy szál folyamatként is végrehajtható.,

• a Python szálának különböző állapotai lehetnek,mint például:

  • várjon,
  • zárolva.

nézzük most megtanulják, hogyan lehet végrehajtani threading Python.

Thread modul Python3

vegye figyelembe, hogy Python3 visszafelé kompatibilis athread modul, amely létezik Python2. 7. A Python3-ban _thread modulként importálható. Vegyünk egy példát, és értsük meg a_thread modult.,

import _thread #thread module importedimport time #time module

definiáljunk egy thread_delay nevű függvényt, amely bemenetként két paramétert vesz fel, azaz a szál nevét és a késleltetést. Ezen a függvényen belül:

• definiál egy nullával rendelkező számlálót,
• akkor egy while hurokkal körbejár, amely háromszor fut,
• a while hurokban ,akkor atime.sleep() késleltetés hozzáadásához ez a késleltetés hasznos lesz a szál végrehajtásának megértéséhez., Ez a késleltetés másodpercben,
• akkor növeli a számláló 1,
• , hogy ha a szál végrehajtása megy simán, akkor nyomtassa ki a nevét a szál, valamint az idő, amikor a szál kerül végrehajtásra.

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

most a szálfunkció hozzáadásához vagy a fenti funkció futtatásához a szálban a start_new_threadmódszert használja, amely a _thread module módszer belsejében található.

lássuk a start_new_thread módszer docstringjét.,

?_thread.start_new_thread

nézzük át a funkció thread_delay zárójel nélkül a két érv, azaz szál nevét, valamint a késedelem (hogy szemléltesse a szál végrehajtása, mivel nagyon gyorsan).

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

a fenti kimenetből látható, hogy a fut először., Eközben a t2 menet 3 másodperces késéssel vár, és amint ez a késés befejeződik, a t2 menet késleltetése t1 csak 1 másodperc.

most változtassuk meg a t2 késleltetését 5 másodpercre, ami t2 után t1 befejezte volna a végrehajtást, mivel t1 csak 3 másodpercet vesz igénybe a végrehajtás befejezéséhez.,

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

menetvágás végrehajtása a menetvágó modul segítségével

használjuk ugyanazt a példát, mint a fentiekben használtuk, de ezúttal a threadingmodult használjuk a _thread modul helyett.

import threadingimport time

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

a threading modul a Thread osztály, amely hasonló a start_new_thread a _thread modul funkciója.,

nézzük meg a Thread osztály docstringjét, amely több paramétert vesz igénybe, mint például a csoport, a cél (mint egy függvény), az args stb.

?threading.Thread

a menetosztály konstruktorában a thread_delay és a függvény argumentumai.,

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

a menetvágó modulban a menet futtatásához vagy végrehajtásához a start() módszert használja, amely egyszerűen felelős a szál futtatásáért.

?t1.start

t1.start()t2.start()

div id=”7ac98bf6a3″> módszer, ami azt jelenti, hogy várjon, amíg az összes szál végrehajtása befejeződik., Tehát bármilyen kódot írt a join metódus után, csak akkor kerül végrehajtásra, ha ezek a szálak megszűntek.

?t1.join

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

kocka és négyzet a menetvágási koncepció segítségével, ami elég egyenesen előre.

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!")

Várj; mi? Amint végrehajtotta a start módszert, hibát eredményezett., Ez azért van, mert a args paramétert vár leírónak, mivel a volume_cube vagy volume_square elvárja, hogy csak egy paraméter, ezért meg kell tenni a vesszőt a args paraméter megadása után az első érv a funkciók.

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!

tanuljuk meg a menetvágást alosztályként használni.,

Menetvágás

alosztályként ebben a szakaszban megtanulhatja, hogyan hozhat létre alosztályt a menetosztályból, amely a menetvágó modulon belül elérhető, majd hozzon létre szálpéldányokat t1 és t2 ebből az osztályból.

ugyanazt a thread_delay funkciót használná itt is.

most nézzük megérteni a fenti kódot lépésről lépésre:

• egy osztályt úgy definiáltál, mint DataCampThread, az osztály argumentumban pedig a threading.Thread osztályban., Ennek oka az, hogy egy alosztályt szeretne létrehozni a threading modulból. Ezzel lehetővé teszi az összes olyan módszer használatát, amely elérhető a threading.Thread osztályban, hasonlóan az öröklés fogalmához.

• ezután meghatározta a DataCampThread osztály init módszerét, majd a késleltetéssel együtt átadta a függvényt. Az init a threading.Thread osztály paramétereihez hasonló konstruktor, itt a DataCampThread osztályra kerül.,

• ezután inicializálja a fő menetvágás init módszerét.Menet osztály, majd egyenlővé név és késleltetés.

• ezután meghatározzuk a run módszert, emlékezzünk itt a start metódusra, amely alapvetően a motorháztető alatt a run metódust hívja. Mivel örökölte a fő osztályt, módosíthatja a run módszert., Ezért, amikor a start metódust hívja, bármilyen módosítást hajt végre a run metódusban, most tükröződik.

következtetés

gratulálunk a bemutató befejezéséhez.

Ez a bemutató alapvető bevezetés volt a Python menetvágásához. A menetvágás azonban nagyon nagy és létfontosságú téma, és néhány fogalom talán még feltáratlan maradt. Nyugodtan nézzen meg több menetvágási módszert, mint például az aktív szám, az aktuális szál stb.

Ha többet szeretne megtudni, akkor nézze meg a Python szál alapú párhuzamosságát is.,

Ha még csak most kezded el a Python-ot, és szeretnél többet megtudni, Vedd át a DataCamp bevezetését a Data Science in Python tanfolyamra.