Mundo ng Python Programming

Python Multiprocessing: Gabay mula Batayan hanggang Advanced

Multithreading, Parallel Processing, at Asynchronous Processing
目次

1. Panimula

Python ay isang programming language na maraming gamit, na nagbibigay ng napakalakas na tool sa larangan ng pagproseso ng data, machine learning, at web development. Sa loob nito, ang multiprocessing module ay isang mahalagang library para maisakatuparan ang parallel processing. Sa artikulong ito, tatalakayin nang detalyado mula sa mga pangunahing gamit ng multiprocessing module ng Python hanggang sa mga advanced na aplikasyon, kasama ang mga biswal na karagdagan, at ipakikilala ang mga praktikal na teknik upang mapakawalan ang pinakamataas na performance.

2. Ano ang multiprocessing?

2.1 Kahalagahan ng Parallel Processing

Python karaniwang tumatakbo sa single thread, ngunit kapag humahawak ng mabibigat na proseso o malaking datos, may hangganan ang bilis ng pagproseso gamit ang pamamaraang ito. Sa pamamagitan ng paggamit ng parallel processing, maaaring magsagawa ng maraming gawain nang sabay-sabay, magamit nang husto ang lahat ng core ng CPU, at mapabilis ang oras ng pagproseso. multiprocessing module ay nag-iwas sa GIL (Global Interpreter Lock) ng Python, at ginagawang posible ang tunay na parallel processing gamit ang maraming proseso.

2.2 Pagkakaiba sa Single Thread

Sa single thread, isang proseso ang sunud-sunod na nagpapatupad ng mga gawain, ngunit sa multi-process maraming proseso ang sabay-sabay na nagpoproseso ng mga gawain. Dahil dito, lalong tumataas ang performance lalo na sa mga CPU-bound na gawain (halimbawa, malalaking kalkulasyon sa numeriko o pagsusuri ng datos).

3. Pangunahing Sintaks ng multiprocessing Module

3.1 Paggamit ng Process Class

multiprocessing Ang pangunahing gamit ng multiprocessing module ay ang paggamit ng Process class. Sa paggamit ng class na ito, madaling makalikha ng bagong proseso at magsagawa ng sabayang pagproseso.
import multiprocessing

def worker_function():
    print("Naisakatuparan ang bagong proseso")

if __name__ == "__main__":
    process = multiprocessing.Process(target=worker_function)
    process.start()
    process.join()
Sa code na ito, pinapatakbo ang worker_function sa isang bagong proseso. Sa start() method, sinisimulan ang proseso, at sa join() method, naghihintay para sa pagtatapos ng proseso.

3.2 Paano Magpasa ng Argumento sa Proseso

Upang magpasa ng argumento sa proseso, gamitin ang args parameter. Sa halimbawa sa ibaba, pinapasa ang argumento sa function na worker upang ito ay tumakbo.
def worker(number):
    print(f'Worker {number} ay naisakatuparan')

if __name__ == "__main__":
    process = multiprocessing.Process(target=worker, args=(5,))
    process.start()
    process.join()
Sa ganitong paraan, maaari kang magpasa ng dynamic na data sa proseso.

4. Pagbabahagi ng Data at Pag-sinkronisa

4.1 Pagbabahagi ng Data gamit ang Shared Memory

Sa multi-process, gumagamit ng Value at Array upang ligtas na magbahagi ng data sa pagitan ng mga proseso. Bilang mga shared memory object, pinapayagan nila ang maraming proseso na sabay-sabay na ma-access at ligtas na manipulahin ang data.
import multiprocessing

def increment_value(shared_value):
    with shared_value.get_lock():
        shared_value.value += 1

if __name__ == "__main__":
    shared_value = multiprocessing.Value('i', 0)
    processes = [multiprocessing.Process(target=increment_value, args=(shared_value,)) for _ in range(5)]

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    print(f'Huling halaga: {shared_value.value}')
Ang code sa itaas ay isang halimbawa kung saan limang proseso ang sabay-sabay na nag-iincrement ng integer value sa loob ng shared memory. Ginagamit ang get_lock() upang maiwasan ang data race.

4.2 Pag-iwas sa Data Race gamit ang Lock

Kapag maraming ang sabay-sabay na nag-ooperate sa data, ginagamit ang lock mechanism upang maiwasan ang data race. Sa pamamagitan ng paggamit ng object na Lock, natitiyak ang pag-sinkronisa sa pagitan ng mga proseso.

5. Pagpamahagi ng mga gawain gamit ang Process Pool

5.1 Paggamit ng Pool class

Pool class, kapag ginamit, maaari mong hatiin ang maraming gawain at patakbuhin ito nang sabay-sabay sa maraming proseso. Napaka-kapaki-pakinabang kapag kailangan ng malaking pagproseso ng data o pamamahagi ng gawain.
from multiprocessing import Pool

def square(x):
    return x * x

if __name__ == "__main__":
    with Pool(4) as pool:
        results = pool.map(square, range(10))
    print(results)
Sa code na ito, kinukuwenta ang parisukat ng bawat elemento ng listahan, at hinahati ito sa 4 na proseso para patakbuhin nang magkakasabay. Sa pamamagitan ng paggamit ng function na map(), madaling maipapamahagi ang mga gawain sa mga proseso.

Diagram: Pagpamahagi ng gawain gamit ang Pool class

タスク分配の流れ

5.2 Halimbawa ng aplikasyon: Pagproseso ng maraming argumento gamit ang starmap

starmap() Kapag ginamit, maaaring iproseso nang sabay-sabay ang mga function na may maraming argumento. Halimbawa, maaari mong gawin ito batay sa mga pares ng argumento tulad ng sumusunod.
def multiply(x, y):
    return x * y

if __name__ == "__main__":
    with Pool(4) as pool:
        results = pool.starmap(multiply, [(1, 2), (3, 4), (5, 6), (7, 8)])
    print(results)

6. Pinakamainam na Paggamit ng CPU Resources

6.1 cpu_count() para i-optimize ang bilang ng mga proseso

Sa pamamagitan ng paggamit ng multiprocessing.cpu_count() ng Python, maaari mong awtomatikong makuha ang bilang ng pisikal na core ng sistema at itakda ang bilang ng mga proseso alinsunod dito. Sa ganitong paraan, maiiwasan ang labis na paglikha ng mga proseso at ma-optimize ang kabuuang pagganap ng sistema.
from multiprocessing import Pool, cpu_count

if __name__ == "__main__":
    with Pool(cpu_count() - 1) as pool:
        results = pool.map(square, range(100))
    print(results)

6.2 Epektibong Paggamit ng mga Resors ng Sistema

Iwasan ang paggamit ng lahat ng CPU core, at mag-iwan ng isang core para sa sistema, upang ma-parallelize ang mga proseso nang hindi naaapektuhan ang ibang mga gawain.

7. Mga Aktwal na Kaso ng Paggamit at Pinakamahusay na Kasanayan

7.1 Konkreto na Halimbawa ng Kaso ng Paggamit

Ang multiprocessing ay epektibo sa mga sumusunod na sitwasyon.
  • Malawak na Pagproseso ng Data: Nakakatulong kapag nagbabasa at nagpoproseso ng maraming file nang sabay-sabay.
  • Parallel Training sa Machine Learning: Pinapabilis ang pagsasanay ng modelo sa pamamagitan ng sabay-sabay na pagpapatakbo sa maraming proseso.
  • Web Crawling: Maaaring mag-crawl ng maraming pahina nang sabay-sabay at epektibong mangolekta ng data.

7.2 Pinakamahusay na Kasanayan

  • Optimal na Pamamahagi ng Resources: Itakda ang tamang bilang ng mga proseso batay sa bilang ng pisikal na core ng system.
  • Paggamit ng Debugging at Logging: Gamitin ang logging module upang subaybayan ang estado ng bawat proseso at isagawa nang maayos ang error handling.
import logging
import multiprocessing

def worker_function():
    logging.info(f'Proseso {multiprocessing.current_process().name} ay nagsimula')

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    process = multiprocessing.Process(target=worker_function, name='Trabahador1')
    process.start()
    process.join()
Sa code na ito, ginagamit ang logging upang irekord ang mga gawain ng bawat proseso, at magawang tingnan ang mga log pagkatapos.
  • Pagpapatupad ng Error Handling: Sa multiprocessing, mahalaga ang error handling dahil maraming proseso ang tumatakbo nang sabay. Kahit na ang isang proseso ay biglang huminto, dapat hindi maapektuhan ang pangunahing proseso o iba pang proseso; gamitin ang try-except upang ipatupad ang error handling.

8. Buod

Sa artikulong ito, ipinaliwanag namin kung paano epektibong magpatupad ng parallel processing gamit ang multiprocessing module ng Python. Mula sa pangunahing paggamit ng Process class, hanggang sa pagbabahagi ng data at paglalaan ng mga gawain gamit ang process pool, at hanggang sa mga totoong use case, ipinakilala namin ang mga praktikal na teknik para magamit ang multiprocessing. Sa pamamagitan ng tamang paggamit ng parallel processing, posible na mapalaki ang performance sa iba’t ibang proyekto tulad ng malakihang pagproseso ng data, pagsasanay ng mga modelo ng machine learning, at web crawling. Ang multiprocessing module ay isang makapangyarihang tool na epektibong ginagamit ang mga system resources at lubos na nagpapabuti sa kakayahan ng Python sa pagproseso. Hinihikayat naming gamitin ang nilalaman na ito bilang sanggunian at subukang ipatupad ang multiprocessing sa inyong pang-araw-araw na gawain sa pag-develop.