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

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

परिचय

जब हम मल्टीप्रोसेसिंग के साथ काम करते हैं, तो सबसे पहले हम प्रक्रिया . बनाते हैं वस्तु। फिर यह एक प्रारंभ () विधि कहता है।

उदाहरण कोड

from multiprocessing import Process
   def display():
      print ('Hi !! I am Python')
      if __name__ == '__main__':
      p = Process(target=display)
      p.start()
      p.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

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

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

उदाहरण

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']

पाइप दो कनेक्शन ऑब्जेक्ट लौटाते हैं और ये पाइप के दो सिरों का प्रतिनिधित्व करते हैं। प्रत्येक कनेक्शन ऑब्जेक्ट की दो विधियाँ होती हैं, एक है भेजें () और दूसरी है recv () विधि।

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

कतार

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

उदाहरण

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

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

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

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

ताला करता है

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

लॉक विधि का उपयोग करने का उदाहरण

उदाहरण

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')

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