El 2019 ha estat un any molt important per al desenvolupament tecnològic a tot el món. A partir dels fabricants d’ordinadors que afegeixen més nuclis a les seves CPU i processadors per al llançament de xips més intel·ligents als telèfons mòbils, el processament múltiple ja no és un somni. Avui en dia, un dels llenguatges de programació més destacats que admet el multiprocessament és . Gràcies a la seva introducció de potència de processament paral·lela a la seva versió, els codificadors de tot el món ara poden crear codis per executar-los simultàniament i, per tant, el seu temps d'execució en una quantitat important.
Les següents indicacions es tractaran en aquest article,
començar amb el banc de treball mysql
Multiprocessament a Python
Què és el multiprocessament?
El multiprocessament es pot definir simplement com la capacitat d’un sistema per donar suport a més d’una operació en una instància determinada. Això vol dir que les aplicacions en sistemes de processament múltiple es divideixen en petits trossos i després funcionen independentment entre si per tal d’augmentar l’eficiència i reduir el temps d’execució general. El processador del sistema assigna a cada peça petita un fil independent que li permet funcionar com una entitat autònoma.
La necessitat del multiprocessament
Imagineu-vos un sistema informàtic que només té un nucli al processador. Si s’assignen diverses tasques a aquest nucli únic, ha de trencar cada tasca entre elles i passar a la següent. Això no augmentarà la quantitat de temps que es necessita per completar cada tasca, sinó que també reduirà l'eficiència general del sistema.
D'altra banda, un ordinador multiprocessador pot tenir un processador que al seu torn té diverses unitats de funcionament al seu interior, anomenats nuclis individuals que tenen la capacitat d'executar diverses tasques diferents al mateix temps. Això no només augmenta l'eficiència del sistema, sinó que, a la llarga, redueix el temps d'execució del sistema en una quantitat significativa.
Un sistema de processament múltiple a Python pot ser de dos tipus.
Sistema de processador múltiple
Aquest sistema té bàsicament diversos processadors sota el capó, cadascun dels quals pot realitzar una tasca a la vegada i funcionar com a component independent.
Sistema de processador multi-nucli
Aquest sistema té diversos nuclis presents en el mateix processador, dins dels quals el nucli funciona com una unitat independent i realitza tasques independentment que se li assignen.
Codi de multiprocessament a Python
Ara que ja esteu acostumat al concepte bàsic de multiprocessament, anem a explorar com es pot aconseguir el multiprocessament a Python.
A Python, l’intèrpret conté una API molt senzilla i intuïtiva que pren una sola tasca, la divideix en diversos components i els processa de forma independent.
Mireu el mòdul del programa següent per entendre millor aquest concepte de multiprocessament en python.
Exemple 1
# importing the multiprocessing module import multiprocessing def print_cube (num): '' 'function to print cub of done given' '' print ('Cube: {}'. format (num * num * num)) def print_square (num): '' 'funció per imprimir quadrat del número donat' '' imprimir ('Quadrat: {}'. format (num * num)) si __name__ == '__main__': # processos de creació p1 = multiprocessament. Procés (target = print_square, args = (10,)) p2 = multiprocessament. Procés (objectiu = cub_impressió, args = (10,)) # procés d'inici 1 p1.start () # procés d'inici 2 p2.start () # espera fins que finalitzi el procés 1 p1 .join () # espereu fins que s'acabi el procés 2 p2.join () # ambdós processos acaben d'imprimir ('Fet!')Sortida
Quadrat: 100
Cub: 1000
Fet!
Ara analitzem aquest programa per entendre'l millor.
El primer pas és importar el mòdul de processament múltiple. Per fer-ho, utilitzeu la sintaxi següent: importar multiprocessament.
Ara que s'ha importat el mòdul de processament múltiple, avancem i creem un procés. Per fer-ho, creem un objecte de classe Process i li assignem els arguments següents. Objectiu: la funció que cal executar mitjançant aquest procés i args: els arguments que cal passar a la funció objectiu.
Nota: Un constructor de processos té la capacitat d’adoptar múltiples objectius i arguments, però a l’exemple anterior només hem assignat al nostre procés dos objectius i arguments tal com es mostra a continuació.
p1 = multiprocessing.Process (target = print_square, args = (10,))
p2 = multiprocessament. Procés (objectiu = cub_impressió, args = (10,))
Ara que s'ha creat el procés, escrivim la sintaxi per iniciar-lo.
p1.start ()
p2.start ()
Un cop iniciat el procés, el programa actual i el que ja s'està executant s'estan executant simultàniament. Si en una situació determinada, heu d’aturar l’execució del programa actual i centrar-vos només en l’execució del programa preexistent, fem servir la funció d’unió com es mostra a continuació.
p1.join ()
p2.join ()
Un cop introduïu aquesta sintaxi, l'intèrpret esperarà que el programa p1 finalitzi l'execució i, a continuació, passarà al programa p2.
Per entendre més aquest concepte, consulteu un altre exemple de multiprocessament a Python a continuació.
Exemple 2
# importing the multiprocessing module import multiprocessing import os def worker1 (): # procés d'impressió id imprimir ('ID del procés en execució worker1: {}'. format (os.getpid ())) def worker2 (): # procés d'impressió imprimir ('ID del procés que s'executa a worker2: {}'. Format (os.getpid ())) si __name__ == '__main__': # imprimir el procés principal del programa print id ('ID del procés principal: {}'. Format (os .getpid ())) # processos de creació p1 = multiprocessament.Procés (objectiu = treballador1) p2 = multiprocessament.Procés (objectiu = treballador2) # processos inicials p1.start () p2.start () # process IDs print ('ID of process p1: {} '. format (p1.pid)) print (' ID del procés p2: {} '. format (p2.pid)) # espereu fins que finalitzin els processos p1.join () p2.join () # ambdós processos han acabat d'imprimir ('Els dos processos han finalitzat l'execució!') # comproveu si els processos estan vius print ('El procés p1 està viu: {}'. format (p1.is_alive ())) print ('El procés p2 està viu: {} '.format (p2.is_alive ()))Sortida
Identificador del procés principal: 18938
Identificador del procés en execució del treballador1: 18939
Identificador del procés en execució de worker2: 18940
Identificador del procés p1: 18939
Identificador del procés p2: 18940
Tots dos processos van acabar l'execució.
Fibonacci recursiu c ++
El procés p1 és viu: fals
El procés p2 és viu: fals
Fixeu-vos al programa anterior que tant el procés p1 com el p2 s’executen independentment de les seves memòries individuals. Tan bon punt ambdues han acabat l'execució, el programa s'acaba.
Això ens porta al final d’aquest article sobre multiprocessament a Python
Per obtenir coneixements en profunditat sobre Python juntament amb les seves diverses aplicacions, podeu fer-ho per a formació en línia en directe amb assistència les 24 hores del dia, els 7 dies de la setmana i accés durant tota la vida.
Tens alguna pregunta? Esmenta’ls a la secció de comentaris de l’article i et respondrem.