बहु-पिरोया और बहु-प्रक्रिया पायथन अनुप्रयोगों को लिखना सीखना

यह लेख अनुभवी पाइथन टैमर्स के लिए नहीं है, जिनके लिए यह साँप की गेंद को खोलना बच्चों की मस्ती है, बल्कि हाल ही में अजगर पर झुकी हुई बहु-थ्रेडेड क्षमताओं का एक सतही अवलोकन है।

दुर्भाग्य से, पायथन में मल्टीथ्रेडिंग के विषय पर रूसी में बहुत अधिक सामग्री नहीं है, और अजगर जो कुछ भी नहीं सुनते थे, उदाहरण के लिए, जीआईएल के बारे में, मेरे साथ व्यवहारिक नियमितता के साथ मेरे पास आना शुरू हुआ। इस लेख में मैं बहुमूत्र अजगर की सबसे बुनियादी विशेषताओं का वर्णन करने की कोशिश करूंगा, आपको बताएगा कि जीआईएल क्या है और इसके साथ कैसे रहना है (या इसके बिना) और बहुत कुछ।


अजगर एक आकर्षक प्रोग्रामिंग भाषा है। यह पूरी तरह से कई प्रोग्रामिंग प्रतिमानों को जोड़ती है। अधिकांश कार्य जो एक प्रोग्रामर का सामना कर सकते हैं, आसानी से, सुरुचिपूर्ण ढंग से और संक्षिप्त रूप से यहां हल किए जाते हैं। लेकिन इन सभी कार्यों के लिए, एक एकल-थ्रेडेड समाधान अक्सर पर्याप्त होता है, और एकल-थ्रेडेड प्रोग्राम आमतौर पर अनुमानित और डिबग करने में आसान होते हैं। बहु-थ्रेडेड और बहु-प्रक्रिया कार्यक्रमों के साथ ऐसा नहीं है।

बहुविकल्पी अनुप्रयोगों

पायथन में एक थ्रेडिंग मॉड्यूल है, और इसमें वह सब कुछ है जो आपको बहु-थ्रेडेड प्रोग्रामिंग के लिए चाहिए: इसमें विभिन्न प्रकार के ताले, एक सेमीफोर और एक घटना तंत्र हैं। एक शब्द में - जो बहुसंख्यक बहुसांस्कृतिक कार्यक्रमों के लिए आवश्यक है। इसके अलावा, इन सभी उपकरणों का उपयोग करना काफी सरल है। एक उदाहरण कार्यक्रम पर विचार करें जो 2 धागे लॉन्च करता है। एक धागा दस "0" लिखता है, दूसरा दस "1" लिखता है, और सख्ती से बदले में।

import threading def writer(x, event_for_wait, event_for_set): for i in xrange(10): event_for_wait.wait() # wait for event event_for_wait.clear() # clean event for future print x event_for_set.set() # set event for neighbor thread # init events e1 = threading.Event() e2 = threading.Event() # init threads t1 = threading.Thread(target=writer, args=(0, e1, e2)) t2 = threading.Thread(target=writer, args=(1, e2, e1)) # start threads t1.start() t2.start() e1.set() # initiate the first event # join threads to the main thread t1.join() t2.join() 

कोई जादू या वूडू कोड नहीं। कोड स्पष्ट और सुसंगत है। इसके अलावा, जैसा कि आप देख सकते हैं, हमने एक फ़ंक्शन से एक स्ट्रीम बनाई। छोटे कार्यों के लिए यह बहुत सुविधाजनक है। यह कोड भी काफी लचीला है। मान लें कि हमारे पास एक तीसरी प्रक्रिया है जो "2" लिखती है, फिर कोड इस तरह दिखेगा:

 import threading def writer(x, event_for_wait, event_for_set): for i in xrange(10): event_for_wait.wait() # wait for event event_for_wait.clear() # clean event for future print x event_for_set.set() # set event for neighbor thread # init events e1 = threading.Event() e2 = threading.Event() e3 = threading.Event() # init threads t1 = threading.Thread(target=writer, args=(0, e1, e2)) t2 = threading.Thread(target=writer, args=(1, e2, e3)) t3 = threading.Thread(target=writer, args=(2, e3, e1)) # start threads t1.start() t2.start() t3.start() e1.set() # initiate the first event # join threads to the main thread t1.join() t2.join() t3.join() 

हमने एक नई घटना, एक नया धागा जोड़ा और मापदंडों को थोड़ा बदल दिया
थ्रेड्स शुरू (बेशक, आप का उपयोग करके एक अधिक सामान्य समाधान लिख सकते हैं, उदाहरण के लिए, MapReduce, लेकिन यह पहले से ही इस लेख के दायरे से परे है)।
जैसा कि आप देख सकते हैं, अभी भी कोई जादू नहीं है। सब कुछ सरल और स्पष्ट है। और आगे चलते हैं।

वैश्विक दुभाषिया ताला

धागे का उपयोग करने के दो सबसे आम कारण हैं: सबसे पहले, आधुनिक प्रोसेसर के मल्टी-कोर आर्किटेक्चर का उपयोग करने की दक्षता बढ़ाने के लिए, और इसलिए, कार्यक्रम प्रदर्शन;
दूसरे, अगर हमें कार्यक्रम के तर्क को समानांतर पूर्ण या आंशिक रूप से अतुल्यकालिक वर्गों में विभाजित करने की आवश्यकता है (उदाहरण के लिए, एक ही समय में कई सर्वरों को पिंग करने में सक्षम)।

पहले मामले में, हम इस तरह के ग्लोबल इंटरप्रेटर लॉक (या शॉर्ट के लिए जीआईएल) के रूप में पायथन की एक सीमा (या इसके मुख्य कार्यान्वयन के रूप में सीपीथॉन) का सामना कर रहे हैं। जीआईएल की अवधारणा यह है कि किसी भी समय, प्रोसेसर द्वारा केवल एक धागे को निष्पादित किया जा सकता है। ऐसा किया जाता है ताकि अलग-अलग चर के लिए अलग-अलग थ्रेड के बीच कोई संघर्ष न हो। निष्पादन योग्य धागा पूरे पर्यावरण में पहुंच जाता है। पायथन में धागा कार्यान्वयन की यह सुविधा थ्रेड्स के साथ काम को सरल करती है और एक निश्चित थ्रेड सुरक्षा प्रदान करती है।

लेकिन एक सूक्ष्म बिंदु है: ऐसा लग सकता है कि एक बहु-थ्रेडेड एप्लिकेशन बिल्कुल उसी समय काम करेगा जैसे एकल-थ्रेडेड अनुप्रयोग, एक ही काम कर रहा है, या सीपीयू पर प्रत्येक थ्रेड के निष्पादन समय के योग के लिए। लेकिन यहां हम एक अप्रिय प्रभाव की प्रतीक्षा कर रहे हैं। कार्यक्रम पर विचार करें:

 with open('test1.txt', 'w') as fout: for i in xrange(1000000): print >> fout, 1 

यह प्रोग्राम केवल फ़ाइल के लिए "1" की एक लाख पंक्तियाँ लिखता है और यह मेरे कंप्यूटर पर ~ 0.35 सेकंड में करता है।

एक अन्य कार्यक्रम पर विचार करें:

 from threading import Thread def writer(filename, n): with open(filename, 'w') as fout: for i in xrange(n): print >> fout, 1 t1 = Thread(target=writer, args=('test2.txt', 500000,)) t2 = Thread(target=writer, args=('test3.txt', 500000,)) t1.start() t2.start() t1.join() t2.join() 

यह प्रोग्राम 2 थ्रेड बनाता है। प्रत्येक थ्रेड में, वह एक अलग फाइल में लिखती है "1" की एक लाख लाइनें। वास्तव में, कार्य की मात्रा पिछले कार्यक्रम के समान है। लेकिन समय के साथ, यहां एक दिलचस्प प्रभाव प्राप्त होता है। कार्यक्रम 0.7 सेकंड से लेकर 7 सेकंड तक चल सकता है। ऐसा क्यों हो रहा है?

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

UPD: फिलहाल पायथन 3.2 में GIL का बेहतर क्रियान्वयन है जिसमें यह समस्या आंशिक रूप से हल हो जाती है, विशेष रूप से, इस तथ्य के कारण कि नियंत्रण खोने के बाद प्रत्येक थ्रेड को समय से पहले कम समय का इंतजार होता है, जिससे वह GIL पर फिर से कब्जा कर सकता है (वहाँ है) अंग्रेजी में अच्छी प्रस्तुति )

"यह पता चला है कि आप पायथन में कुशल बहु-थ्रेडेड प्रोग्राम नहीं लिख सकते हैं?", आप पूछते हैं। नहीं, बेशक, एक समाधान है, और यहां तक ​​कि कुछ भी।

मल्टीप्रोसेस एप्लिकेशन

एक अर्थ में, पिछले पैराग्राफ में वर्णित समस्या को हल करने के लिए, पायथन में एक सबप्रोसेस मॉड्यूल है। हम एक कार्यक्रम लिख सकते हैं जिसे हम एक समानांतर धागे में निष्पादित करना चाहते हैं (वास्तव में पहले से ही एक प्रक्रिया)। और इसे किसी अन्य प्रोग्राम में एक या अधिक थ्रेड्स में चलाएं। इस तरह की विधि वास्तव में हमारे कार्यक्रम के काम को गति प्रदान करेगी, क्योंकि जीआईएल लॉन्च कार्यक्रम में बनाए गए थ्रेड्स नहीं उठाते हैं, लेकिन केवल चलने की प्रक्रिया के पूरा होने की प्रतीक्षा करते हैं। हालांकि, इस पद्धति के साथ बहुत सारी समस्याएं हैं। मुख्य समस्या यह है कि प्रक्रियाओं के बीच डेटा स्थानांतरित करना मुश्किल हो जाता है। मुझे किसी तरह वस्तुओं को क्रमबद्ध करना होगा, पीआईपीई या अन्य उपकरणों के माध्यम से संचार स्थापित करना होगा, और यह सब अनिवार्य रूप से ओवरहेड लागत वहन करता है और कोड को समझना मुश्किल हो जाता है।

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

इसके अलावा, मल्टीप्रोसेसिंग मॉड्यूल में साझा मेमोरी के साथ काम करने का एक तंत्र है। इसके लिए, मॉड्यूल में चर (मान) और सरणी (सरणी) की कक्षाएं हैं, जो प्रक्रियाओं के बीच "सामान्यीकृत" (साझा) हो सकती हैं। साझा चर के साथ काम करने की सुविधा के लिए, आप प्रबंधक वर्गों (प्रबंधक) का उपयोग कर सकते हैं। वे अधिक लचीले और उपयोग में आसान होते हैं, लेकिन धीमे होते हैं। कोई मल्टीप्रोसेसिंग.शेडिंगपाइप्स मॉड्यूल का उपयोग करके ctypes मॉड्यूल से प्रकार साझा करने के सुखद अवसर को नोट करने में विफल नहीं हो सकता।

मल्टीप्रोसेसिंग मॉड्यूल में प्रक्रिया पूल बनाने के लिए एक तंत्र भी है। यह तंत्र मास्टर-वर्कर टेम्पलेट को लागू करने के लिए या समानांतर मानचित्र (जो मास्टर-वर्कर का एक विशेष मामला है) को लागू करने के लिए उपयोग करने के लिए बहुत सुविधाजनक है।

मल्टीप्रोसेसिंग मॉड्यूल के साथ काम करने की मुख्य समस्याओं में से, इस मॉड्यूल की सापेक्ष प्लेटफ़ॉर्म निर्भरता ध्यान देने योग्य है। चूंकि प्रक्रियाओं के साथ काम अलग-अलग ऑपरेटिंग सिस्टम में अलग-अलग आयोजित किया जाता है, इसलिए कोड पर कुछ प्रतिबंध लगाए जाते हैं। उदाहरण के लिए, विंडोज में कोई कांटा तंत्र नहीं है, इसलिए आपको प्रक्रिया पृथक्करण बिंदु को लपेटने की आवश्यकता है:

 if __name__ =='__main__': 

हालांकि, यह डिजाइन पहले से ही अच्छे फॉर्म में है।

और क्या ...

पायथन में समानांतर अनुप्रयोग लिखने के लिए अन्य पुस्तकालय और दृष्टिकोण हैं। उदाहरण के लिए, आप पायथन (pyMPI, mpi4py) में Hadoop + पायथन या विभिन्न MPI कार्यान्वयन का उपयोग कर सकते हैं। तुम भी मौजूदा C ++ या फोरट्रान पुस्तकालयों के रैपर का उपयोग कर सकते हैं। यहां आप पायरो, ट्विस्टेड, टॉर्नेडो और कई अन्य लोगों के रूप में ऐसी रूपरेखा / पुस्तकालयों का उल्लेख कर सकते हैं। लेकिन यह सब पहले से ही इस लेख के दायरे से परे है।

यदि आपको मेरी शैली पसंद आई, तो अगले लेख में मैं यह बताने की कोशिश करूँगा कि PLY में सरल व्याख्याकारों को कैसे लिखना है और उनका उपयोग क्यों किया जा सकता है।