Какво представлява Mutithreading в Python и как да го постигна?

Времето е най-важният фактор в живота. Благодарение на важността си, светът на програмирането предлага различни трикове и техники, които значително ви помагат да намалите консумацията на време, като по този начин увеличавате производителността. Един такъв подход е Multithreading в Python, който е една от най-важните концепции, обхванати в .

Ето кратко обобщение на всички специалности, обхванати в тази статия:

Какво е многозадачност в Python?
Какво е нишка?
Какво представлява многопоточността в python?
Кога да използвам многопоточност в Python?
Как да постигна многопоточност в Python?
Как да създам нишки в Python?

• без да създавате клас
• чрез удължаване на нишката клас
• без да се разширява класът на нишката

Предимства на използването на многопоточност в Python

Като начало, нека първо се опитаме да разберем многозадачността, преди да започнем да учим за Multithreading в Python.

Какво е многозадачност в Python?

Многозадачността като цяло е способността за едновременно изпълнение на множество задачи. В технически план многозадачността се отнася до способността на операционната система да изпълнява различни задачи едновременно. Например , вие изтегляте нещо на вашия компютър, както слушате песни и едновременно играете игра и т.н. Всички тези задачи се изпълняват от една и съща операционна система в синхрон. Това не е нищо друго освен многозадачност, която не само ви помага да спестите време, но и увеличава производителността.

Има два типа мултитаскинг в операционната система:

• Въз основа на процеса
• На основата на нишки

В тази статия ще научите за На основата на нишки многозадачност или Многопоточност .

Какво е нишка?

Конецът е основно независим поток на изпълнение. Един процес може да се състои от множество нишки. Всяка нишка в програма изпълнява определена задача. Например, когато играете игра, кажете FIFA на вашия компютър, играта като цяло е един процес , но се състои от няколко нишки, отговорни за възпроизвеждане на музиката, вземане на вход от потребителя, синхронно стартиране на противника и т.н. Всичко това са отделни нишки, отговорни за изпълнението на тези различни задачи в една и съща програма.

Всеки процес има една нишка, която винаги се изпълнява. Това е основната нишка. Тази основна нишка всъщност създава обектите на дъщерни нишки. Детската нишка също се инициира от основната нишка. По-нататък в тази статия ще ви покажа как да проверите текущата работеща нишка.

разширява и прилага заедно в java

Така че с това, надявам се, че ясно сте разбрали какво представлява нишката. Продължавайки, нека видим какво е Multithreading в Python.

Кога да използвам Multithreading в Python?

Многопоточността е много полезна за спестяване на време и подобряване на производителността, но не може да се прилага навсякъде.
В предишния пример на FIFA, музикалната нишка е независима от нишката, която приема вашия вход, а нишката, която приема вашия вход, е независима от нишката, която управлява вашия опонент. Тези нишки се изпълняват независимо, защото не са взаимно зависими.

Следователно многопоточността може да се използва само когато зависимостта между отделните нишки не съществува.

Тази статия допълнително показва как можете да постигнете Multithreading в Python.

Как да постигна многопоточност в Python?

Многопоточност в Python може да се постигне чрез импортиране на резбоване модул.

Преди да импортирате този модул, ще трябва да го инсталирате. За да инсталирате това във вашата среда на anaconda, изпълнете следната команда на вашия ред на anaconda:

conda install -c conda-forge tbb

След успешното му инсталиране можете да използвате някоя от следните команди за импортиране на модула за резба:

внос резба от резба внос *

Сега, след като сте инсталирали модул за резби, нека продължим напред и направим Multithreading в Python.

Как да създам нишки в Python?

Темите в Python могат да бъдат създадени по три начина:

1. Без да създавате клас
2. Чрез удължаване на клас Thread
3. Без да се разширява класът Thread

Без да създавате клас

Многопоточността в Python може да се осъществи и без създаване на клас. Ето пример за демонстриране на същото:

Пример:

от резба импорт * print (current_thread (). getName ()) def mt (): print ('Child Thread') child = Thread (target = mt) child.start () print ('Изпълнява име на нишка:', current_thread ( ) .getName ())

Изход:

MainThread Child Thread Изпълнява се име на нишка: MainThread

Горният изход показва, че първата нишка, която присъства, е основната нишка. След това тази основна нишка създава дъщерна нишка, която изпълнява функцията и след това окончателният оператор за печат се изпълнява отново от основната нишка.

Сега нека продължим напред и да видим как да направим Multithreading в python, като разширим класа Thread.

Чрез разширяване на класа Thread:

Когато се създава детски клас чрез разширяване на класа Thread, дъщерният клас представя, че нова нишка изпълнява някаква задача. Когато разширява класа Thread, дъщерният клас може да замени само два метода, т.е. метода __init __ () и метода run (). Никой друг метод не може да бъде заменен освен тези два метода.

Ето пример за това как да разширите класа Thread, за да създадете нишка:

Пример:

импортиране на резби клас на време за импортиране mythread (threadading.Thread): def run (self): за x in range (7): print ('Hi from child') a = mythread () a.start () a.join () print ('Чао от', current_thread (). GetName ())

Изход:
Здравей от дете
Здравей от дете
Здравей от дете
Здравей от дете
Здравей от дете
Здравей от дете
Здравей от дете
Чао от MainThread

Горният пример показва, че клас myclass наследява класа Thread и дъщерният клас, т.е. myclass заменя метода run. По подразбиране първият параметър на която и да е функция на класа трябва да бъде самостоятелно, което е указателят към текущия обект. Резултатът показва, че дъщерната нишка изпълнява метода run () и основната нишка чака изпълнението на дъщерното устройство да завърши. Това се дължи на функцията join (), която кара основната нишка да чака детето да завърши.

Този метод за създаване на нишки е най-предпочитаният метод, тъй като е стандартен метод. Но в случай, че искате да създадете нишки, без да наследявате или разширявате класа Thread, можете да го направите по следния начин.

Без удължаване на нишката клас

За да създадете нишка, без да разширявате класа Thread, можете да направите следното:
Пример:

от резба импортиране * клас ex: def myfunc (самостоятелно): # себе си необходим като първи параметър в клас func за x в диапазон (7): print ('Child') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () print ('готово')

Изход:

Дете
Дете
Дете
Дете
Дете
Дете
Дете
Свършен

Предимства на използването на резби

Многопоточността има много предимства, някои от които са следните:

• По-добро използване на ресурсите
• Опростява кода
• Позволява едновременно и паралелно възникване на различни задачи
• Намалява консумацията на време или времето за реакция, като по този начин увеличава производителността.

Ето пример за проверка колко време отнема на код за изпълнение с и без многопоточност в python:

 Пример: 

импортиране на време def sqr (n): за x в n: time.sleep (1) x% 2 def cube (n): за x in n: time.sleep (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) cube (n) e = time.time () print (es)

Изход:

16.042309284210205

Горното е изходното време, необходимо за изпълнение на програмата без използване на нишки. Сега нека използваме нишки и да видим какво се случва със същата програма:

Пример:

импортиране на резби от резби импорт * време за импортиране def sqr (n): за x в n: time.sleep (1) print ('Остатък след разделяне на 2', x% 2) def cube (n): за x в n: time.sleep (1) print ('Остатък след разделяне на 3', x% 3) n = [1,2,3,4,5,6,7,8] start = time.time () t1 = Thread ( target = sqr, args = (n,)) t2 = Thread (target = cube, args = (n,)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () end = time.time () print (end-start)

Горният изход ясно показва, че времето, използвано от нишки, е много по-малко в сравнение с времето, необходимо за изпълнение на същата програма без използване на нишки.

Надявам се, че сте наясно с концепциите, обхванати от тази статия, свързани с многопоточност в Python. Уверете се, че практикувате възможно най-много, тъй като това е една от най-важните концепции, използвани в програмирането.

Имате въпрос към нас? Моля, споменете го в раздела за коментари в този блог „Многопоточност в Python“ и ние ще се свържете с вас възможно най-скоро.

За да получите задълбочени познания за Python заедно с различните му приложения, можете да се регистрирате за живо с 24/7 поддръжка и доживотен достъп.