Mi az a mutathreading a Pythonban, és hogyan érhető el?

Ismerje meg, mi a multitasking a pythonban. Azt is elmagyarázza, hogy miként lehet szálakat létrehozni osztály létrehozása nélkül, a Thread osztály kibővítésével és anélkül, hogy kibővítené, a többszálas szálat.

Az élet a legkritikusabb tényező az életben. Fontosságának köszönhetően a programozás világa különböző trükköket és technikákat kínál, amelyek jelentősen segítenek csökkenteni az időfogyasztást, ezáltal növelve a teljesítményt. Az egyik ilyen megközelítés a Multithreading a Pythonban, amely az egyik legfontosabb fogalom, amelyre kiterjed .



Itt található egy rövid összefoglaló a cikkben szereplő összes szakról:



Mi a többfeladatos a Pythonban?
Mi az a szál?
Mi az a többszálas szál a pythonban?
Mikor használja a többszálas szálat a Pythonban?
Hogyan lehet elérni a többszálas szálat Pythonban?
Hogyan lehet szálakat létrehozni a Pythonban?

A multithreading Python-ban történő használatának előnyei



Először próbálkozzunk a multitasking megértésével, mielőtt elkezdenénk megismerni a Multithreading programot a Pythonban.

Mi a multitasking a Pythonban?

A többfeladatos feladat általában több feladat egyidejű végrehajtása. Technikai értelemben a multitasking az operációs rendszer azon képességére utal, hogy egyszerre különböző feladatokat hajtson végre. Például , valamit letölt a számítógépére, valamint hallgat zeneszámokat és párhuzamosan játszik egy játékot stb. Mindezeket a feladatokat ugyanaz az operációs rendszer és szinkronizálja. Ez nem más, mint a multitasking, amely nemcsak időt takarít meg, hanem növeli a termelékenységet is.

Kétféle típusú multitasking van egy operációs rendszerben:



  • Folyamat alapú
  • Szálalapú

Ebben a cikkben megismerheti Szálalapú multitasking vagy Többszálas .

Mi az a szál?

threads-multithreading a python-edureka fájlbanEgy szál alapvetően egy független a végrehajtás folyása. Egyetlen folyamat több szálból állhat. A program minden szála elvégez egy adott feladatot. Például, játék közben mondd a FIFA-t a számítógépeden, a játék egésze egyetlen folyamat , de több szálból áll, amelyek felelősek a zene lejátszásáért, a felhasználótól a bemenet megszerzéséért, az ellenfél szinkron futtatásáért stb. Mindezek külön szálak, amelyek felelősek azért, hogy ezeket a különböző feladatokat ugyanazon programban hajtsák végre.

Minden folyamatnak van egy szála, amely mindig fut. Ez a fő szál. Ez a fő szál valójában létrehozza a gyermek szál objektumokat. A gyermekszálat is a főszál kezdeményezi. Ebben a cikkben mindannyian megmutatom, hogyan ellenőrizheti az aktuális futó szálat.

c ++ rendező tömb növekvő sorrendben

Tehát ezzel remélem, hogy világosan megértette, mi az a szál. Továbblépve nézzük meg, mi a Multithreading a Pythonban.

Mikor kell használni a Multithreading programot a Pythonban?

A többszálas futtatás nagyon hasznos az időmegtakarításhoz és a teljesítmény javításához, de nem mindenhol alkalmazható.
Az előző FIFA példában a zenei szál független attól a száltól, amelyik beveszi a bemenetét, és az a szál, amelyik beviszi, független az ellenfelet futtató száltól. Ezek a szálak egymástól függetlenül futnak, mert nem függenek egymástól.

Ezért a többszálas szálak csak akkor használhatók, ha az egyes szálak közötti függőség nem létezik.

Ez a cikk tovább bemutatja, hogyan lehet elérni a többszálas szálat Pythonban.

Hogyan lehet elérni a többszálas szálat Pythonban?

A Pythonban többszálas szálfuttatás érhető el a szálfűzés modul.

A modul importálása előtt telepítenie kell. Ennek telepítéséhez az anaconda környezetbe hajtsa végre a következő parancsot az anaconda parancssorban:

conda install -c conda-forge tbb

Sikeres telepítése után a következő parancsok bármelyikével importálhatja a szálmodult:

import szálak szálakból import *

Most, hogy telepítve van a szálmodul, hadd lépjünk előre, és végezzük a Multithreading programot a Pythonban.

Hogyan lehet szálakat létrehozni a Pythonban?


A Python szálai háromféleképpen hozhatók létre:

  1. Osztály létrehozása nélkül
  2. A Thread osztály kibővítésével
  3. A Thread osztály kibővítése nélkül

Osztály létrehozása nélkül

A Pythonban történő többszálas futtatás osztály létrehozása nélkül is megvalósítható. Itt van egy példa ugyanezek bemutatására:

Példa:

importálásból import * print (current_thread (). getName ()) def mt (): print ('Child Thread') gyermek = Thread (target = mt) child.start () print ('A szál nevének végrehajtása:', current_thread ( ) .getName ())

Kimenet:

MainThread gyermekszál A szál nevének végrehajtása: MainThread

A fenti kimenet azt mutatja, hogy az első jelen lévő szál a fő szál. Ez a fő szál létrehoz egy utódszálat, amely végrehajtja a függvényt, majd a végső nyomtatási utasítást a fő szál ismét végrehajtja.

Most lépjünk előre, és nézzük meg, hogyan kell a többszálas programot végrehajtani a pythonban a Szál osztály kibővítésével.

A Thread osztály kibővítésével:

Amikor a szál osztály kibővítésével jön létre egy gyermekosztály, a gyermek osztály azt jelzi, hogy egy új szál valamilyen feladatot hajt végre. A Szál osztály kiterjesztésekor a gyermek osztály csak két módszert írhat felül, azaz a __init __ () és a run () metódust. E két módszeren kívül semmilyen más módszer nem írható felül.

Íme egy példa a Thread osztály kibővítésére egy szál létrehozására:

Példa:

import szál importálása import osztály osztálylista (threading.Thread): def run (self): x-re a tartományban (7): print ('Hi from child') a = mythread () a.start () a.join () print ('Viszlát', current_thread (). GetName ())

Kimenet:
Szia gyermektől
Szia gyermektől
Szia gyermektől
Szia gyermektől
Szia gyermektől
Szia gyermektől
Szia gyermektől
Viszlát a MainThread-től

A fenti példa azt mutatja, hogy a myclass osztály örökli a Thread osztályt, és a gyermek osztály, vagyis a myclass felülírja a futási módszert. Alapértelmezés szerint bármely osztályfüggvény első paraméterének önmagának kell lennie, amely az aktuális objektum mutatója. A kimenet azt mutatja, hogy a gyermek szál végrehajtja a run () metódust, és a fő szál várja a gyermek végrehajtásának befejezését. Ennek oka a join () függvény, amely a fő szálat arra várja, hogy a gyermek befejezze.

Ez a szálak létrehozásának módszere a legelőnyösebb módszer, mivel ez a szokásos módszer. De abban az esetben, ha szálakat szeretne létrehozni a Szál osztály öröklése vagy kiterjesztése nélkül, a következő módon teheti meg.

A Thread osztály kiterjesztése nélkül

Szál létrehozásához a Szál osztály kibővítése nélkül a következőket teheti:
Példa:

a threading importból * class ex: def myfunc (self): #self required mint első paraméter egy osztályban func for x tartományban (7): print ('Child') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () print ('kész')

Kimenet:

Gyermek
Gyermek
Gyermek
Gyermek
Gyermek
Gyermek
Gyermek
Kész

A gyermek szál végrehajtja a myfunc funkciót, amely után a fő szál végrehajtja az utolsó nyomtatási utasítást.

A menetes használat előnyei

A többszálas szálnak számos előnye van, amelyek közül néhány a következő:

  • Az erőforrások jobb kihasználása
  • Egyszerűsíti a kódot
  • Lehetővé teszi a különböző feladatok egyidejű és párhuzamos előfordulását
  • Csökkenti az időfogyasztást vagy a válaszidőt, ezáltal növelve a teljesítményt.

Itt van egy példa annak ellenőrzésére, hogy mennyi időbe telik, amíg egy kód többszálas futtatással és anélkül is futtatható a pythonban:

 Példa: 
import ideje def sqr (n): x-hez n: time.sleep (1) x% 2 def kocka (n): x-hez n: time.sleep (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) kocka (n) e = time.time () print (ek)

Kimenet:

16.042309284210205

A fenti a kimeneti idő, amely a program futtatásához szükséges szálak használata nélkül. Most használjunk szálakat, és nézzük meg, mi történik ugyanazzal a programmal:

Példa:

szál importálása a szálból importálás * importálási idő def sqr (n): x-hez n-ben: time.sleep (1) print ('maradék 2-vel osztás után', x% 2) def kocka (n): x-hez n-ben: time.sleep (1) print ('maradék 3-mal való elosztás után', x% 3) n = [1,2,3,4,5,6,7,8] start = time.time () t1 = Thread ( target = sqr, args = (n,)) t2 = Szál (target = kocka, args = (n,)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () end = time.time () print (end-start)
Kimenet: 9.040220737457275

A fenti kimenet egyértelműen azt mutatja, hogy a szálak használatához szükséges idő sokkal kevesebb ahhoz az időhöz képest, amelyre ugyanazon program futtatása szükséges szálak használata nélkül.

Remélem, tisztában van az ebben a cikkben tárgyalt fogalmakkal a Multithreading Python-ban. Győződjön meg arról, hogy a lehető legtöbbet gyakorolja, mivel ez az egyik legfontosabb fogalom, amelyet a programozás során használnak.

Van egy kérdésünk? Kérjük, említse meg a „Multithreading in Python” blog megjegyzés szakaszában, és mi akarat a lehető leghamarabb forduljon hozzád.

Ha mélyreható ismereteket szeretne szerezni a Pythonról és a különböző alkalmazásokról, regisztrálhat élőben 24/7 támogatással és élethosszig tartó hozzáféréssel.