पायथन में प्रक्रियाओं का सिंक्रनाइज़ेशन और पूलिंग

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

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

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

उदाहरण कोड

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

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

पूलिंग

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

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

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

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

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

यह apply() बिल्ट-इन फ़ंक्शन के समान है। यह तब तक ब्लॉक होता है जब तक परिणाम तैयार नहीं हो जाता, यदि यह समानांतर में प्रदर्शन करना चाहता है तो apply_async() मेथड बेहतर है।

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

एक परिणाम ऑब्जेक्ट लौटाता है।

map(func, iterable [, chunksize])

map() एक बिल्ट-इन फ़ंक्शन है और यह केवल एक इटरेबल तर्क का समर्थन करता है। यह तब तक ब्लॉक होता है जब तक परिणाम तैयार नहीं हो जाता।

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

map_async(func, iterable[, chunksize[, callback]])

एक परिणाम ऑब्जेक्ट लौटाता है।

imap(func, iterable[, chunksize])

यह itertools.imap() के समान है।

तर्क का आकार map() में उपयोग किए गए के समान है।

imap_unordered(func, iterable[, chunksize])

यह imap() के समान है सिवाय इसके कि वापसी इटरेक्टर क्रमबद्ध होना चाहिए।

close()

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

terminate()

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

join()

join() मेथड का उपयोग करने से पहले, हमें close() और terminate() फ़ंक्शन का उपयोग करना होगा।

class multiprocessing.pool.AsyncResult

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

get([timeout])

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

wait([timeout])

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

ready()

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

successful()

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

उदाहरण कोड

# -*- 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)  # 4 वर्कर प्रक्रियाएं शुरू करें
    result = my_pool.apply_async(myfunction, (10,))  # एकल प्रक्रिया में "f(10)" का अतुल्यकालिक मूल्यांकन
    print(result.get(timeout=1))
    print(my_pool.map(myfunction, range(10)))  # "[0, 1, 4,..., 81]" प्रिंट करता है
    my_it = my_pool.imap(myfunction, range(10))
    print(my_it.next())  # "0" प्रिंट करता है
    print(my_it.next())  # "1" प्रिंट करता है
    print(my_it.next(timeout=1))  # "4" प्रिंट करता है जब तक कि आपका कंप्यूटर *बहुत* धीमा न हो
    result = my_pool.apply_async(time.sleep, (10,))
    print(result.get(timeout=1))  # multiprocessing.TimeoutError उठाता है