पायथन में मल्टीप्रोसेसिंग

मल्टीप्रोसेसिंग पैकेज प्रक्रियाओं को जन्म देने का समर्थन करता है। यह एक फ़ंक्शन को संदर्भित करता है जो एक नई चाइल्ड प्रक्रिया को लोड और निष्पादित करता है। चाइल्ड के समाप्त होने या समवर्ती कंप्यूटिंग को जारी रखने के लिए, वर्तमान प्रक्रिया को एक API का उपयोग करके प्रतीक्षा करनी होती है, जो थ्रेडिंग मॉड्यूल के समान है।

परिचय

जब हम मल्टीप्रोसेसिंग के साथ काम करते हैं, तो सबसे पहले हम process ऑब्जेक्ट बनाते हैं। फिर यह start() मेथड को कॉल करता है।

उदाहरण कोड

from multiprocessing import Process
def display():
    print('Hi !! I am Python')
    if __name__ == '__main__':
        p = Process(target=display)
        p.start()
        p.join()

इस उदाहरण में, पहले हम Process क्लास इम्पोर्ट करते हैं फिर display() फ़ंक्शन के साथ Process ऑब्जेक्ट आरंभ करते हैं।

फिर प्रक्रिया को start() मेथड से शुरू किया जाता है और फिर join() मेथड से प्रक्रिया पूरी होती है।

हम args कीवर्ड का उपयोग करके फ़ंक्शन में तर्क भी पास कर सकते हैं।

उदाहरण

from multiprocessing import Process
def display(my_name):
    print('Hi !!!' + " " + my_name)
    if __name__ == '__main__':
        p = Process(target=display, args=('Python',))
        p.start()
        p.join()

इस उदाहरण में, हम एक प्रक्रिया बनाते हैं जो संख्याओं का घन गणना करता है और सभी परिणामों को कंसोल पर प्रिंट करता है।

उदाहरण कोड

from multiprocessing import Process
def cube(x):
    for x in my_numbers:
        print('%s cube is %s' % (x, x**3))
    if __name__ == '__main__':
        my_numbers = [3, 4, 5, 6, 7, 8]
        p = Process(target=cube, args=('x',))
        p.start()
        p.join()
        print("Done")

आउटपुट

Done
3 cube is 27
4 cube is 64
5 cube is 125
6 cube is 216
7 cube is 343
8 cube is 512

हम एक समय में एक से अधिक प्रक्रिया भी बना सकते हैं।

इस उदाहरण में, पहले हम एक प्रक्रिया बनाते हैं जो process1 है, यह प्रक्रिया केवल एक संख्या का घन गणना करती है और उसी समय दूसरी प्रक्रिया process2 जांचती है कि यह संख्या सम है या विषम।

उदाहरण

from multiprocessing import Process
def cube(x):
    for x in my_numbers:
        print('%s cube is %s' % (x, x**3))
def evenno(x):
    for x in my_numbers:
        if x % 2 == 0:
            print('%s is an even number ' % (x))
    if __name__ == '__main__':
        my_numbers = [3, 4, 5, 6, 7, 8]
        my_process1 = Process(target=cube, args=('x',))
        my_process2 = Process(target=evenno, args=('x',))
        my_process1.start()
        my_process2.start()
        my_process1.join()
        my_process2.join()
        print("Done")

आउटपुट

3 cube is 27
4 cube is 64
5 cube is 125
6 cube is 216
7 cube is 343
8 cube is 512
4 is an even number
6 is an even number
8 is an even number
Done

प्रक्रियाओं के बीच संचार

मल्टीप्रोसेसिंग पाइप्स और क्यूज़ का समर्थन करता है, जो प्रक्रियाओं के बीच संचार के दो प्रकार के चैनल हैं।

पाइप्स

मल्टीप्रोसेसिंग में, जब हम प्रक्रियाओं के बीच संचार करना चाहते हैं, तो उस स्थिति में पाइप्स का उपयोग किया जाता है।

उदाहरण

from multiprocessing import Process, Pipe
def myfunction(conn):
    conn.send(['hi!! I am Python'])
    conn.close()
    if __name__ == '__main__':
        parent_conn, child_conn = Pipe()
        p = Process(target=myfunction, args=(child_conn,))
        p.start()
        print(parent_conn.recv())
        p.join()

आउटपुट

['hi !!! I am Python']

पाइप्स दो कनेक्शन ऑब्जेक्ट लौटाते हैं और ये पाइप के दो छोरों को दर्शाते हैं। प्रत्येक कनेक्शन ऑब्जेक्ट में दो मेथड होते हैं एक send() और दूसरा recv() मेथड।

इस उदाहरण में, पहले हम एक प्रक्रिया बनाते हैं और यह प्रक्रिया संदेश "hi!! I am Python" प्रिंट करती है और फिर डेटा साझा करती है।

क्यूज़

जब हम प्रक्रियाओं के बीच डेटा पास करते हैं तो उस समय हम Queue ऑब्जेक्ट का उपयोग कर सकते हैं।

उदाहरण

import multiprocessing
def evenno(numbers, q):
    for n in numbers:
        if n % 2 == 0:
            q.put(n)
    if __name__ == "__main__":
        q = multiprocessing.Queue()
        p = multiprocessing.Process(target=evenno, args=(range(10), q))
        p.start()
        p.join()
        while q:
            print(q.get())

आउटपुट

0
2
4
6
8

इस उदाहरण में, पहले एक फ़ंक्शन बनाते हैं जो जांचता है कि कोई संख्या सम है या नहीं। यदि संख्या सम है, तो उसे क्यू के अंत में डालें। फिर हम एक क्यू ऑब्जेक्ट और एक प्रक्रिया ऑब्जेक्ट बनाते हैं फिर हम प्रक्रिया शुरू करते हैं।

और अंत में जांचते हैं कि क्यू खाली है या नहीं।

जब हम संख्याओं को प्रिंट करते हैं, तो पहले हम वह मान प्रिंट करते हैं जो क्यू के सामने है फिर अगला और इसी तरह।

लॉक्स

जब हम चाहते हैं कि केवल एक प्रक्रिया एक समय में निष्पादित हो तो उस स्थिति में लॉक्स का उपयोग किया जाता है। इसका मतलब है कि उस समय अन्य प्रक्रियाओं को समान कोड निष्पादित करने से रोकता है। प्रक्रिया पूरी होने के बाद लॉक जारी किया जाएगा।

लॉक्स मेथड का उपयोग करके उदाहरण

उदाहरण

from multiprocessing import Process, Lock
def dispmay_name(l, i):
    l.acquire()
    print('Hi', i)
    l.release()
if __name__ == '__main__':
    my_lock = Lock()
    my_name = ['Aadrika', 'Adwaita', 'Sakya', 'Sanj']
    for name in my_name:
        Process(target=dispmay_name, args=(my_lock, name)).start()

आउटपुट

Hi Aadrika
Hi Adwaita
Hi Sakya
Hi Sanj

लॉगिंग

मल्टीप्रोसेसिंग मॉड्यूल लॉगिंग मॉड्यूल भी प्रदान करता है यह सुनिश्चित करने के लिए कि, यदि लॉगिंग पैकेज लॉक्स फ़ंक्शन का उपयोग नहीं करता है, तो निष्पादन के दौरान प्रक्रियाओं के बीच संदेश मिश्रित हो जाते हैं।

उदाहरण

import multiprocessing, logging
logger = multiprocessing.log_to_stderr()
logger.setLevel(logging.INFO)
logger.warning('Error has occurred')

इस उदाहरण में पहले हम लॉगिंग और मल्टीप्रोसेसिंग मॉड्यूल इम्पोर्ट करते हैं फिर हम multiprocessing.log_to_stderr() मेथड का उपयोग करते हैं। और यह get_logger() को कॉल करता है साथ ही sys.stderr में जोड़ता है और अंत में हम लॉगर का स्तर सेट करते हैं और संदेश देते हैं।