पायथन में प्रक्रियाओं का तुल्यकालन और पूलिंग

प्रक्रियाओं के बीच सिंक्रनाइज़ेशन

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

इस पैकेज में सभी समकक्ष सिंक्रोनाइज़ेशन प्रिमिटिव मौजूद हैं।

उदाहरण कोड

from multiprocessing import Process, Lock
   def my_function(x, y):
      x.acquire()
      print ('hello world', y)
      x.release()
      if __name__ == '__main__':
      lock = Lock()
   for num in range(10):
Process(target= my_function, args=(lock, num)).start()

यहां यह सुनिश्चित करने के लिए एक इंस्टेंस लॉक हो सकता है कि एक समय में केवल एक प्रक्रिया मानक आउटपुट प्रदर्शित कर सकती है।

पूलिंग

पूलिंग के लिए, हम पूल क्लास का उपयोग करते हैं। जब कोई प्रक्रियाओं का एक पूल बना सकता है जो उसे सबमिट किए गए सभी कार्यों को पूरा करेगा।

class multiprocessing.Pool([processes[, initializer[, initargs[, maxtasksperchild]]]])

एक पूल ऑब्जेक्ट कार्यकर्ता के एक पूल को नियंत्रित करता है कि कौन सा कार्य सबमिट किया जा सकता है और यह एसिंक्रोनस परिणाम का समर्थन करता है जिसमें टाइमआउट, कॉलबैक और समानांतर मानचित्र कार्यान्वयन होता है।

cpu_count() का उपयोग किया जाता है यदि प्रक्रिया कोई नहीं है और प्रारंभकर्ता (* intargs) यह फ़ंक्शन कॉल करता है जब प्रारंभकर्ता कोई नहीं होता है।

apply(func[, args[, kwds]])

यह लागू () अंतर्निहित फ़ंक्शन के समान है। यह परिणाम तैयार होने तक अवरुद्ध है, अगर यह समानांतर में प्रदर्शन करना चाहता है तो apply_async() विधि बेहतर है।

apply_async(func[, args[, kwds[, callback]]])

एक परिणाम वस्तु देता है।

नक्शा(func, iterable [, chunksize])

map() एक अंतर्निहित फ़ंक्शन है और यह केवल एक चलने योग्य तर्क का समर्थन करता है। यह परिणाम तैयार होने तक ब्लॉक करता है।

इस पद्धति में, चलने योग्य कई छोटे टुकड़ों में टूट जाता है और इन छोटे भागों को एक अलग कार्य के रूप में प्रक्रिया पूल में जमा किया जाता है।

map_async(func, iterable[, chunksize[, कॉलबैक]])

एक परिणाम वस्तु देता है।

इमैप(func, iterable[, chunksize])

यह itertools.imap() जैसा ही है।

तर्क का आकार वही है जो मानचित्र () में उपयोग किया गया है।

imap_unordered(func, iterable[, chunksize])

यह imap() जैसा ही है, सिवाय इसके कि पुनरावर्तन पुनरावर्तक का आदेश दिया जाना चाहिए।

बंद करें ()

जब एक कार्यकर्ता सभी कार्यों को पूरा कर लेता है तो कार्यकर्ता प्रक्रिया से बाहर निकल जाता है।

समाप्त करें ()

यदि हम कार्य को पूरा किए बिना तुरंत कार्यकर्ता प्रक्रिया को रोकना चाहते हैं तो इस पद्धति का उपयोग किया जाता है।

शामिल हों ()

ज्वाइन () विधि का उपयोग करने से पहले, हमें क्लोज () और टर्मिनेट () फ़ंक्शन का उपयोग करना चाहिए।

कक्षा multiprocessing.pool.AsyncResult

Pool.apply_async() और Pool.map_async() द्वारा लौटाया गया।

प्राप्त करें([समयबाह्य])

यह फ़ंक्शन आने पर परिणाम लौटाता है।

प्रतीक्षा करें([समयबाह्य])

इस प्रतीक्षा फ़ंक्शन का उपयोग करके, हम परिणाम उपलब्ध होने या टाइमआउट सेकंड बीतने तक प्रतीक्षा करते हैं।

तैयार ()

यह फ़ंक्शन देता है कि कॉल पूरा हुआ या नहीं।

सफल ()

बिना किसी त्रुटि के कॉल पूर्ण होने पर यह फ़ंक्शन वापस आ जाता है।

उदाहरण कोड

# -*- coding: utf-8 -*-
"""
Created on Sun Sep 30 12:17:58 2018
@author: Tutorials Point
"""
from multiprocessing import Pool
import time
def myfunction(m):
return m*m
if __name__ == '__main__':
my_pool = Pool(processes=4) # start 4 worker processes
result = my_pool.apply_async(myfunction, (10,)) # evaluate "f(10)" asynchronously in a single process
print (result.get(timeout=1))
print (my_pool.map(myfunction, range(10))) # prints "[0, 1, 4,..., 81]"
my_it = my_pool.imap(myfunction, range(10))
print (my_it.next() ) # prints "0"
print (my_it.next() ) # prints "1"
print (my_it.next(timeout=1) ) # prints "4" unless your computer is *very* slow
result = my_pool.apply_async(time.sleep, (10,))
print (result.get(timeout=1) ) # raises multiprocessing.TimeoutError