Мултипроцесорът е сравним с многонишковия. Въпреки това, това се отличава с това, че можем да изпълняваме само една нишка в даден момент поради GIL, който се използва за нишки. Мултипроцесорът е процес на извършване на операции последователно в няколко процесорни ядра. Нишките не могат да се управляват паралелно. Мултипроцесирането обаче ни позволява да установим процесите и да ги изпълняваме едновременно на различни процесорни ядра. Цикълът, като for-loop, е един от най-често използваните скриптови езици. Повторете същата работа, като използвате различни данни, докато бъде достигнат критерий, като например предварително определен брой повторения. Цикълът извършва всяка итерация една по една.
Пример 1: Използване на For-Loop в Python Multiprocessing Module
В този пример използваме for-цикъла и процеса на класа на многопроцесорния модул на Python. Започваме с много ясен пример, за да можете бързо да разберете как работи многопроцесорният for-цикъл на Python. Използвайки интерфейс, който е сравним с модула за нишки, мултипроцесорът пакетира създаването на процеси.
Чрез използването на подпроцесите, а не на нишките, пакетът за многопроцесорна обработка осигурява както локална, така и отдалечена едновременност, като по този начин избягва глобалното заключване на интерпретатора. Използвайте for-цикъл, който може да бъде низов обект или кортеж, за непрекъснато итериране през последователност. Това работи по-малко като ключовата дума, наблюдавана в други езици за програмиране, и повече като метод на итератор, открит в други езици за програмиране. Като стартирате нова мултипроцесорна обработка, можете да стартирате for-цикъл, който изпълнява процедура едновременно.
Нека започнем с внедряване на кода за изпълнение на код с помощта на инструмента „spyder“. Вярваме, че „spyder“ също е най-добрият за работа с Python. Ние импортираме процес на многопроцесорен модул, който кодът изпълнява. Мултипроцесирането в концепцията на Python, наречено „клас на процес“, създава нов процес на Python, дава му метод за изпълнение на код и дава на родителското приложение начин да управлява изпълнението. Класът Process съдържа процедурите start() и join(), като и двете са от решаващо значение.
След това дефинираме дефинирана от потребителя функция, наречена „func“. Тъй като това е дефинирана от потребителя функция, ние й даваме име по наш избор. В тялото на тази функция предаваме променливата „subject“ като аргумент и стойността „maths“. След това извикваме функцията „print()“, като предаваме израза „Името на общия субект е“, както и неговия аргумент „тема“, който съдържа стойността. След това в следващата стъпка използваме „if name== _main_“, което ви пречи да изпълнявате кода, когато файлът е импортиран като модул, и ви позволява да го правите само когато съдържанието се изпълнява като скрипт.
Секцията за условие, с която започвате, може да се разглежда в повечето случаи като място за предоставяне на съдържание, което трябва да се изпълнява само когато вашият файл се изпълнява като скрипт. След това използваме аргумента субект и съхраняваме някои стойности в него, които са „наука“, „английски“ и „компютър“. След това на процеса се дава името „process1[]“ в следващата стъпка. След това използваме „process(target=func)“, за да извикаме функцията в процеса. Target се използва за извикване на функцията и ние запазваме този процес в променливата „P“.
След това използваме „process1“, за да извикаме функцията „append()“, която добавя елемент в края на списъка, който имаме във функцията „func“. Тъй като процесът се съхранява в променливата „P“, ние предаваме „P“ на тази функция като неин аргумент. Накрая използваме функцията “start()” с “P”, за да стартираме процеса. След това стартираме метода отново, като предоставяме аргумента „subject“ и използваме „for“ в темата. След това, използвайки „process1“ и метода „add()“ още веднъж, започваме процеса. След това процесът се изпълнява и изходът се връща. След това на процедурата се казва да приключи с помощта на техниката 'join()'. Процесите, които не извикват процедурата „join()“, няма да излязат. Един важен момент е, че параметърът на ключовата дума „args“ трябва да се използва, ако искате да предоставите някакви аргументи чрез процеса.
Сега можете да видите в изхода, че операторът се показва първо чрез предаване на стойността за предмета „maths“, който предаваме на функцията „func“, защото първо я извикваме с помощта на функцията „process“. След това използваме командата 'append()', за да имаме стойности, които вече са били в списъка, който се добавя в края. След това бяха представени „наука“, „компютър“ и „английски език“. Но, както можете да видите, стойностите не са в правилната последователност. Това е така, защото те го правят веднага щом процедурата приключи и докладват своето съобщение.
Пример 2: Преобразуване на последователен For-цикъл в многопроцесорен паралелен For-цикъл
В този пример многопроцесорната циклична задача се изпълнява последователно, преди да бъде преобразувана в паралелна for-циклична задача. Можете да преминавате през поредици като колекция или низ в реда, в който се появяват, като използвате for-циклите.
Сега нека започнем да прилагаме кода. Първо импортираме „сън“ от модула за време. Използвайки процедурата “sleep()” в модула за време, можете да спрете изпълнението на извикващата нишка за толкова дълго, колкото желаете. След това използваме „random“ от произволния модул, дефинираме функция с името „func“ и предаваме ключовата дума „argu“. След това създаваме произволна стойност с помощта на „val“ и я задаваме на „random“. След това блокираме за кратък период от време, като използваме метода “sleep()” и предаваме “val” като параметър. След това, за да предадем съобщение, изпълняваме метода “print()”, като предаваме думите “ready” и ключовата дума “arg” като негов параметър, както и “created” и предаваме стойността с помощта на “val”.
Накрая използваме „flush“ и го настройваме на „True“. Потребителят може да реши дали да буферира или не изхода, като използва опцията за промиване във функцията за печат на Python. Стойността по подразбиране False на този параметър показва, че изходът няма да бъде буфериран. Резултатът се показва като поредица от редове, следващи един след друг, ако го зададете на true. След това използваме „if name== main“, за да защитим входните точки. След това изпълняваме работата последователно. Тук задаваме диапазона на „10“, което означава, че цикълът завършва след 10 итерации. След това извикваме функцията “print()”, предаваме й оператора за въвеждане “ready” и използваме опцията “flush=True”.
Сега можете да видите, че когато изпълняваме кода, цикълът кара функцията да се изпълнява „10“ пъти. Той се повтаря 10 пъти, започвайки от индекс нула и завършвайки с индекс девет. Всяко съобщение съдържа номер на задача, който е номер на функция, който предаваме като „arg“ и номер на създаване.
Този последователен цикъл сега се трансформира в многопроцесорен паралелен for-цикъл. Използваме същия код, но отиваме към някои допълнителни библиотеки и функции за мултипроцесиране. Следователно трябва да импортираме процеса от мултипроцесор, точно както обяснихме по-рано. След това създаваме функция, наречена „func“, и предаваме ключовата дума „arg“, преди да използваме „val=random“, за да получим произволно число.
След това, след извикване на метода “print()” за показване на съобщение и даване на параметъра “val” за малко забавяне, ние използваме функцията “if name= main”, за да защитим входните точки. След това създаваме процес и извикваме функцията в процеса с помощта на „process“ и предаваме „target=func“. След това предаваме „func“, „arg“, предаваме стойността „m“ и предаваме диапазона „10“, което означава, че цикълът прекратява функцията след „10“ итерации. След това стартираме процеса с помощта на метода „start()“ с „process“. След това извикваме метода „join()“, за да изчакаме изпълнението на процеса и да завършим целия процес след това.
Следователно, когато изпълняваме кода, функциите извикват главния процес и започват своето изпълнение. Те обаче се изпълняват, докато не бъдат изпълнени всички задачи. Можем да видим това, защото всяка задача се изпълнява едновременно. Той съобщава съобщението си веднага щом приключи. Това означава, че въпреки че съобщенията не са в ред, цикълът приключва след завършване на всички „10“ итерации.
Заключение
В тази статия разгледахме многопроцесорния for-цикъл на Python. Представихме и две илюстрации. Първата илюстрация показва как да използвате for-цикъл в многопроцесорната библиотека на Python. А втората илюстрация показва как да промените последователен for-цикъл в паралелен многопроцесорен for-цикъл. Преди да конструираме скрипта за мултипроцесор на Python, трябва да импортираме модула за мултипроцесор.