Python Academy · पाठ

multiprocessing की मूल बातें

कई CPU कोर का उपयोग करें

पाठ 3, कुल 4 में से13 चरण

multiprocessing की मूल बातें, CoddyKit पर Python Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Python Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Python Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

मल्टीप्रोसेसिंग क्यों?

GIL थ्रेड्स को Python बाइटकोड को समानांतर रूप से चलाने से रोकता है। multiprocessing मॉड्यूल अलग-अलग प्रक्रियाएँ शुरू करके इस सीमा से बचता है। हर प्रक्रिया का अपना इंटरप्रेटर और GIL होता है, इसलिए CPU-आधारित काम वास्तव में कई कोर पर चलता है।

import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())

प्रक्रिया शुरू करना

Process(target=func) थ्रेडिंग इंटरफ़ेस जैसा ही काम करता है। शुरू करने के लिए start() और प्रतीक्षा करने के लिए join() को कॉल कीजिए।

import multiprocessing as mp

def worker():
    print('hello from a child process')

if __name__ == '__main__':
    p = mp.Process(target=worker)
    p.start()
    p.join()
    print('parent done')

main सुरक्षा-जाँच

कुछ प्लेटफ़ॉर्म पर चाइल्ड प्रक्रियाएँ आपकी स्क्रिप्ट को इंपोर्ट करती हैं। if __name__ == '__main__': सुरक्षा-जाँच के बिना आप प्रक्रियाओं को बार-बार शुरू कर सकते हैं। लॉन्च करने वाले कोड को हमेशा इसके अंदर रखें।

import multiprocessing as mp

def task(n):
    print('processing', n)

if __name__ == '__main__':
    for i in range(3):
        p = mp.Process(target=task, args=(i,))
        p.start()
        p.join()

आर्ग्युमेंट देना

स्थितीय आर्ग्युमेंट के लिए args और कीवर्ड आर्ग्युमेंट के लिए kwargs का उपयोग कीजिए, ठीक थ्रेड्स की तरह। आर्ग्युमेंट्स को पिकल करके चाइल्ड प्रक्रिया को भेजा जाता है।

import multiprocessing as mp

def show(label, times):
    for _ in range(times):
        print(label)

if __name__ == '__main__':
    p = mp.Process(target=show, args=('hi',), kwargs={'times': 2})
    p.start()
    p.join()

वर्करों का पूल

multiprocessing.Pool प्रक्रियाओं के एक समूह का प्रबंधन करता है। pool.map किसी iterable को उनके बीच बाँटता है और परिणामों को क्रम से एकत्र करता है।

import multiprocessing as mp

def square(n):
    return n * n

if __name__ == '__main__':
    with mp.Pool(processes=2) as pool:
        print(pool.map(square, range(6)))

ProcessPoolExecutor

concurrent.futures API ProcessPoolExecutor भी उपलब्ध कराता है, जिसमें वही submit/map इंटरफ़ेस है जिसे आपने थ्रेड्स के लिए देखा था।

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

if __name__ == '__main__':
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(cube, range(5))))

अलग-अलग मेमोरी क्षेत्र

हर प्रक्रिया की अपनी मेमोरी होती है। चाइल्ड प्रक्रिया में किसी ग्लोबल को बदलने से पैरेंट प्रक्रिया की कॉपी नहीं बदलती। डेटा को स्पष्ट रूप से लौटाना या साझा करना आवश्यक है।

import multiprocessing as mp

counter = 0

def bump():
    global counter
    counter += 100

if __name__ == '__main__':
    p = mp.Process(target=bump)
    p.start()
    p.join()
    print('parent counter still:', counter)

परिणाम वापस पाना

क्योंकि मेमोरी साझा नहीं होती, इसलिए ग्लोबल को बदलने के बजाय Pool.map, एक्ज़ीक्यूटर या क्यू के माध्यम से परिणाम लौटाइए।

import multiprocessing as mp

def double(n):
    return n * 2

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        results = pool.map(double, [1, 2, 3, 4])
    print('results:', results)

एकल कॉल के लिए apply_async

apply_async एक कॉल को निर्धारित करता है और परिणाम का हैंडल लौटाता है। मान प्राप्त करने के लिए .get() को कॉल कीजिए।

import multiprocessing as mp

def add(a, b):
    return a + b

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        r = pool.apply_async(add, (3, 4))
        print(r.get())

पिकलिंग की आवश्यकता

लक्ष्य और आर्ग्युमेंट पिकल किए जा सकने योग्य होने चाहिए, ताकि वे प्रक्रिया की सीमा पार कर सकें। शीर्ष-स्तरीय फ़ंक्शन काम करते हैं; लैम्ब्डा और स्थानीय फ़ंक्शन आम तौर पर काम नहीं करते।

import multiprocessing as mp

def top_level(n):
    return n + 1

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        print(pool.map(top_level, [10, 20]))

प्रक्रियाओं का उपयोग कब करें

CPU-आधारित काम के लिए प्रक्रियाओं का उपयोग कीजिए: गणित, इमेज प्रोसेसिंग और पार्सिंग। प्रक्रियाएँ शुरू करने और पिकलिंग की अतिरिक्त लागत के कारण ये कई छोटे कामों के बजाय कम संख्या में भारी कामों के लिए अधिक उपयुक्त हैं।

import multiprocessing as mp

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with mp.Pool() as pool:
        print(pool.map(heavy, [1000, 2000, 3000]))

त्वरित जाँच

मल्टीप्रोसेसिंग के बारे में अपनी समझ का परीक्षण कीजिए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने मल्टीप्रोसेसिंग की मूल बातें सीखीं:

प्रक्रियाएँ वास्तविक CPU समानांतरता के लिए GIL की सीमा से बचती हैं।
if __name__ == '__main__' सुरक्षा-जाँच का उपयोग कीजिए।
Pool और ProcessPoolExecutor काम बाँटते हैं और परिणाम एकत्र करते हैं।
मेमोरी साझा नहीं होती; आर्ग्युमेंट पिकल किए जा सकने योग्य होने चाहिए।

अगला विषय: क्यू और लॉक के साथ डेटा को सुरक्षित रूप से साझा करना।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 76
पाठ: 320

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “multiprocessing की मूल बातें” पाठ निःशुल्क है?

हाँ—“multiprocessing की मूल बातें” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Python Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Python Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“multiprocessing की मूल बातें” में मैं क्या सीखूँगा?

कई CPU कोर का उपयोग करें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Python Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Python Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Python Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“multiprocessing की मूल बातें” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Python Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Python Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Python Academy पर वापस जाएँ