Python Multiprocessing
In this page:
from multiprocessing import Process
process = Process(target=function_name, args=(arg,))
process.start()
process.join()Process बनाम Thread
Python में threads एक ही memory space share करते हैं पर Global Interpreter Lock (GIL) से सीमित होते हैं, इसलिए एक समय में सिर्फ़ एक thread Python bytecode execute करता है।
Multiprocessing हर task को अपने memory space वाले अपने process में चलाकर GIL को पूरी तरह बायपास कर देता है, जिससे CPU-bound काम वाकई कई cores पर parallel में चल सकता है।
उदाहरण: Process vs. Thread
import multiprocessing
print(multiprocessing.cpu_count())एक Basic Process बनाना
Process बनाना एक Process object को instantiate करने और target parameter के ज़रिए अपना target function पास करने से शुरू होता है, चाहें तो उस function के arguments के लिए args भी।
start() call करना एक नया OS process spawn करता है और parent से independent रहते हुए तुरंत आपका function चलाना शुरू कर देता है।
उदाहरण: Creating a Basic Process
import multiprocessing
def task():
print("Running in a process")
if __name__ == "__main__":
p = multiprocessing.Process(target=task)
p.start() # spawns a new OS process
p.join()Processes को Join करना
डिफ़ॉल्ट रूप से main script start() के तुरंत बाद चलता रहता है, इसलिए processes background में execute होते हैं जबकि आपका program आगे बढ़ता रहता है।
join() call करना main script को उस बिंदु पर तब तक block कर देता है जब तक नाम दिया गया process पूरा न हो जाए, जो तब मायने रखता है जब बाद का code उस process के परिणामों के तैयार होने पर depend करता है।
उदाहरण: Joining Processes
import multiprocessing
def task():
print("Process work done")
if __name__ == "__main__":
p = multiprocessing.Process(target=task)
p.start()
p.join() # blocks until the process finishes
print("Main continues after process finishes")Arguments के साथ Multiprocessing
किसी process में data पास करना किसी function को call करने जैसा ही काम करता है: values को एक tuple में bundle करें और Process constructor के args parameter को दे दें।
चूँकि हर process की अलग memory होती है, यही उसमें input पहुँचाने का इकलौता भरोसेमंद तरीका है -- processes के बीच सीधे variable sharing उस तरह काम नहीं करती जैसे threads के साथ करती है।
उदाहरण: Multiprocessing with Arguments
import multiprocessing
def greet(name):
print("Hello,", name)
if __name__ == "__main__":
p = multiprocessing.Process(target=greet, args=("Alex",)) # only way to pass data in, since memory isn't shared
p.start()
p.join()main Guard
अपने multiprocessing entry point को if __name__ == __main__: में लपेटना Windows और macOS पर सबसे ज़्यादा मायने रखता है, जहाँ नए processes आपकी script को शुरू से फिर import करते हैं।
guard के बिना, हर child process उस module-level code को फिर execute कर देगा जो processes spawn करता है, जिससे बेकाबू recursive process creation शुरू हो जाएगी।
उदाहरण: The main Guard
import multiprocessing
def task():
print("Safe process spawn")
if __name__ == "__main__": # prevents runaway recursive process creation on Windows/macOS
p = multiprocessing.Process(target=task)
p.start()
p.join()Chapter Quiz — Complete all 12 topics to unlock
0/12 topics done
Complete these topics first: