目次
- 1 1. Panimula
- 2 2. Mga paraan ng parallel processing sa Python
- 3 3. Multi-proseso vs Multi-thread
- 4 4. Paano magpatupad ng parallel processing sa Python
- 5 5. Asynchronous na Pagproseso at ang mga Gamit Nito
- 6 6. Pag-optimize ng Performance ng Parallel Processing
- 7 7. Praktikal na mga Aplikasyon ng Parallel Processing sa Python
- 8 8. Buod
1. Panimula
Kahalagahan ng Parallel Processing sa Python
Ang Python ay isang simpleng at madaling gamitin na programming language na ginagamit sa maraming layunin. Gayunpaman, kapag kinakailangan ng komplikadong pagproseso ng data o kalkulasyon, ang bilis ng pagproseso ng Python ay maaaring maging hamon. Upang malutas ito, ang “parallel processing” na nagpapahintulot sa sabay-sabay na pagpapatakbo ng maraming gawain ay may mahalagang papel. Sa artikulong ito, tatalakayin kung paano magpatupad ng parallel processing sa Python, mula sa mga pangunahing pamamaraan hanggang sa mga tiyak na use case.2. Mga paraan ng parallel processing sa Python
Mga pangunahing paraan ng parallel processing
May ilang paraan ang Python para maisakatuparan ang parallel processing. Ang mga pangunahing ito ay ang tatlong sumusunod.- Multi-threading (
threadingmodule) Gumagamit ng maraming thread upang isagawa ang mga gawain nang magkasabay, ngunit dahil sa epekto ng Python GIL (Global Interpreter Lock), limitado ang bisa nito para sa mga gawain na gumagamit ng maraming CPU. - Multi-process (
multiprocessingmodule) Dahil ang bawat proseso ay may sariling memory space, hindi ito apektado ng GIL, kaya posible ang tunay na parallel processing. Angkop ito para sa malakihang pagproseso ng data at mabibigat na kalkulasyon. - Asynchronous processing (
asynciomodule) Ang asynchronous processing ay epektibo para sa mga I/O-bound na gawain (tulad ng network communication at file operations). Sa ganitong paraan, maaaring maisakatuparan nang epektibo ang mga prosesong may maraming oras ng paghihintay.
3. Multi-proseso vs Multi-thread
Epekto ng GIL (Global Interpreter Lock)
May mekanismo sa Python na tinatawag na GIL, na naglilimita sa sabay-sabay na pagpapatakbo sa iisang thread lamang. Ito ang dahilan kung bakit sa mga CPU-bound na gawain, hindi tumataas ang performance kahit na magdagdag ng mga thread. Dahil dito, ang parallel processing gamit ang mga thread ay epektibo lamang sa mga I/O-bound na gawain na may maraming oras ng paghihintay.Mga Benepisyo at Limitasyon ng Multi-thread
Ang mga thread ay magaan at angkop para sa mga I/O-bound na gawain (tulad ng paghawak ng file o network processing). Gayunpaman, dahil sa nabanggit na GIL, hindi magagamit nang buo ang maraming CPU core, kaya hindi ito angkop para sa mga CPU-bound na gawain.import threading
import time
def worker(num):
print(f"Worker {num} starting")
time.sleep(2)
print(f"Worker {num} finished")
threads = []
for i in range(5):
t = threading.Thread(target=worker, args=(i,))
threads.append(t)
t.start()
for t in threads:
t.join()Mga Benepisyo ng Multi-proseso
Upang maiwasan ang limitasyon ng GIL, epektibo ang multi-proseso. Ang mga proseso ay iba sa mga thread dahil may sariling memory space, kaya maaaring magamit nang buo ang maraming CPU core. Lalo na kapaki-pakinabang ito sa mabibigat na kalkulasyon o paghawak ng malalaking datos.from multiprocessing import Process
import time
def worker(num):
print(f"Worker {num} starting")
time.sleep(2)
print(f"Worker {num} finished")
if name == 'main':
processes = []
for i in range(5):
p = Process(target=worker, args=(i,))
processes.append(p)
p.start()
for p in processes:
p.join()join() method ay naghihintay hanggang sa matapos ang bawat proseso, kaya hindi magpapatuloy ang programa hanggang sa makumpleto ang lahat ng proseso.4. Paano magpatupad ng parallel processing sa Python
Parallel processing gamit ang multiprocessing module
Kapag ginagamit angmultiprocessing module, maaari mong epektibong pamahalaan ang maraming proseso. Narito ang isang pangunahing halimbawa ng paggamit ng process pool para magproseso ng mga gawain nang parallel.from multiprocessing import Pool
def square(x):
return x * x
if name == 'main':
with Pool(4) as p:
result = p.map(square, [1, 2, 3, 4, 5])
print(result)
5. Asynchronous na Pagproseso at ang mga Gamit Nito
Asynchronous na Pagproseso gamit ang asyncio module
asyncio ay partikular na angkop para sa mga task na may I/O na paghihintay. Ang mga proseso tulad ng network communication at file input/output ay maaaring maisakatuparan nang mas epektibo sa pamamagitan ng pagsabay-sabay na pagproseso ng ibang mga task habang naghihintay.import asyncio
async def worker(num):
print(f'Worker {num} starting')
await asyncio.sleep(1)
print(f'Worker {num} finished')
async def main():
tasks = [worker(i) for i in range(5)]
await asyncio.gather(*tasks)
asyncio.run(main())await, isinasagawa ang asynchronous na pagproseso, at ang ibang mga task ay tumatakbo habang ang bawat task ay naghihintay.
6. Pag-optimize ng Performance ng Parallel Processing
Parallelization gamit ang Joblib
Joblib ay isang library na nag-eefisiyensya ng mabibigat na kalkulasyon tulad ng pagproseso ng data at pagsasanay ng mga modelo ng machine learning. Ang sumusunod na code ay halimbawa ng paggamit ng Joblib para sa parallel processing.from joblib import Parallel, delayed
def heavy_task(n):
return n ** 2
results = Parallel(n_jobs=4)(delayed(heavy_task)(i) for i in range(10))
print(results)n_jobs, maaari mong kontrolin ang bilang ng mga prosesong isasagawa nang sabay. Sa halimbawang ito, isinasagawa ang kalkulasyon nang parallel gamit ang 4 na proseso, at ibinabalik ang resulta bilang isang listahan.7. Praktikal na mga Aplikasyon ng Parallel Processing sa Python
Pagproseso ng Data at Web Scraping
Ang parallel processing sa Python ay lalo na epektibo sa mga sitwasyon kung saan maraming data ang pinoproseso nang sabay, tulad ng pagproseso ng data at web scraping. Halimbawa, kapag nag-crawl ng mga web page, maaaring gumamit ng multi-threading o asynchronous processing upang magsabay-sabay na magpadala ng maraming kahilingan, na nagreresulta sa malaking pag-ikli ng oras ng pagproseso. Bukod pa rito, sa training ng machine learning at pre-processing ng data, maaaring mapabuti ang performance sa pamamagitan ng paggamit ngmultiprocessing at Joblib.8. Buod
Ang parallel processing ay isang mahalagang teknolohiya upang makuha ang pinakamataas na pagganap ng Python.threading, multiprocessing, asyncio, at Joblib na mga module ay maaaring gamitin nang tama upang epektibong iproseso ang mga gawain sa iba’t ibang sitwasyon. Gamitin ang mga teknolohiyang ito sa mga totoong proyekto at magsikap na mapabuti ang kahusayan ng pagproseso. 
