Python mul­tip­ro­cessing ļauj sadalīt darba slodzi starp vairākiem procesiem, samazinot kopējo izpildes laiku. Tas ir īpaši noderīgi, veicot apjomīgus aprēķinus vai ap­strā­dā­jot lielus datu kopumus.

Kas ir Python daudzpro­ce­su apstrāde?

Daudzpro­ce­su apstrāde Python valodā nozīmē vairāku procesu vien­lai­cī­gu izpildi, kas ļauj maksimāli izmantot daudzko­do­lu sistēmu iespējas. Atšķirībā no vien­ko­do­lu metodēm, kas apstrādā uzdevumus vienu pēc otra, daudzpro­ce­su apstrāde ļauj prog­ram­mas dažādām daļām darboties paralēli, katrai atsevišķi. Katram procesam ir sava atmiņas telpa, un tas var darboties at­se­viš­ķos procesoru kodolos, ie­vē­ro­ja­mi samazinot smagu vai laika ziņā jutīgu operāciju izpildes laiku.

Python mul­tip­ro­cessing ir plašs pie­lie­to­ju­mu klāsts. Mul­tip­ro­cessing bieži tiek izmantots datu apstrādē un analīzē, lai ātrāk ap­strā­dā­tu lielus datu kopumus un pa­āt­ri­nā­tu sa­rež­ģī­tas analīzes. Daudzpro­ce­su apstrāde var tikt izmantota arī si­mu­lā­ci­jās un mo­de­lē­ša­nas aprēķinos (piemēram, zi­nāt­nis­kās lie­to­jum­prog­ram­mās), lai saīsinātu sarežģītu aprēķinu izpildes laiku. Papildus tīmekļa satura ieguvei, vien­lai­kus iegūstot datus no vairākām vietnēm, tā arī palielina efek­ti­vi­tā­ti attēlu apstrādē un da­torre­dzē­ša­nā, rezultātā paātrinot attēlu analīzi.

Kā īstenot Python daudzpro­ce­su apstrādi

Python piedāvā dažādas iespējas daudzpro­ce­su apstrādes īs­te­no­ša­nai. Turp­mā­ka­jās sadaļās ie­pa­zīs­ti­nā­sim jūs ar trim iz­pla­tī­tā­ka­jiem rīkiem: multiprocessing moduli, concurrent.futures bib­lio­tē­ku un joblib paketi.

multiprocessing modulis

multiprocessing modulis ir standarta modulis Python daudzpro­ce­su apstrādei. Ar šo moduli varat izveidot procesus, dalīties ar datiem starp tiem un sin­hro­ni­zēt tos, iz­man­to­jot blo­ķē­ju­mus, rindas un citus rīkus.

import multiprocessing
def task(n):
    result = n * n
    print(f"Result: {result}")
if __name__ == "__main__":
    processes = []
    for i in range(1, 6):
        process = multiprocessing.Process(target=task, args=(i,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()
python

Iepriekš minētajā piemērā mēs iz­man­to­jam multiprocessing.Process klasi, lai radītu un palaistu procesus, kas izpilda task() funkciju, kura aprēķina dotā skaitļa kvadrātu. Pēc procesu ini­cia­li­zē­ša­nas mēs gaidām, līdz tie tiek pabeigti, pirms turpinām galveno programmu. Rezultāts tiek parādīts, iz­man­to­jot f-string, Python string formāta metodi, kas ietver iz­teik­smes. Ir vērts atzīmēt, ka izvades secība ir nejauša un ne­de­ter­mi­nis­tis­ka. Ar Python multiprocessing varat arī izveidot procesu kopu:

import multiprocessing
def task(n):
    return n * n
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(task, range(1, 6))
        print(results)  # Output: [1, 4, 9, 16, 25]
python

Ar pool.map() funkcija task() tiek piemērota datu secībai, un rezultāti tiek apkopoti un izvadīti.

concurrent.futures bib­lio­tē­ka

Šis modulis nodrošina augsta līmeņa saskarni asin­hro­nai izpildei un paralēlai procesu apstrādei. Tas izmanto Pool Executor, lai izpildītu uzdevumus procesu vai pavedienu kopumā. concurrent.futures modulis ir vien­kār­šāks veids, kā apstrādāt asin­hro­nus uzdevumus, un daudzos gadījumos tas ir vieglāk lietojams nekā Python multiprocessing modulis.

import concurrent.futures
def task(n):
    return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
    futures = [executor.submit(task, i) for i in range(1, 6)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result()) # result in random order
python

Kods izmanto concurrent.futures module, lai ap­strā­dā­tu uzdevumus paralēli ar ProcessPoolExecutor. Funkcija task(n) tiek nodota skaitļiem no 1 līdz 5. Metode as_completed() gaida, līdz uzdevumi tiek pabeigti, un izvada re­zul­tā­tus jebkurā secībā.

joblib pakete

joblib ir ārēja Python bib­lio­tē­ka, kas iz­strā­dā­ta, lai vien­kār­šo­tu paralēlo apstrādi Python, piemēram, at­kār­to­ja­miem uz­de­vu­miem, tādiem kā funkciju izpilde ar dažādiem ievades pa­ra­met­riem vai darbs ar lieliem datu apjomiem. joblib galvenās funkcijas ir uzdevumu pa­ra­lē­li­zā­ci­ja, funkciju rezultātu kešēšana un atmiņas un skait­ļo­ša­nas resursu op­ti­mi­zā­ci­ja.

from joblib import Parallel, delayed
def task(n):
    return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: Results of the function for numbers from 1 to 10
python

Izteiksme Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) iniciē funkcijas task() paralēlu izpildi skaitļiem no 1 līdz 10. Parallel ir kon­fi­gu­rēts ar n_jobs=4, kas nozīmē, ka var apstrādāt līdz četriem pa­ra­lē­liem uz­de­vu­miem. Izsaukums delayed(task)(i) izveido uzdevumu, kas jāizpilda paralēli katram skaitlim i diapazonā no 1 līdz 10. Tas nozīmē, ka funkcija task() tiek izsaukta vien­lai­kus katram no šiem skaitļiem. Rezultāti skaitļiem no 1 līdz 10 tiek saglabāti results un izvadīti.

Go to Main Menu