👩‍👩‍👦‍👦 💧 👩🏼‍🤝‍👨🏻 एक मल्टीथ्रेडेड C ++ एप्लिकेशन में पायथन का उपयोग करना और पायथन में सच्चे मल्टीथ्रेडिंग का उपयोग करना ⚠️ 🚥 ☮️

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

पायथन में ईमानदार बहुस्तरीयता

निम्नलिखित सभी पायथन 3.2 में पेश किए गए नए जीआईएल पर आधारित है, डीबग किया गया है, और पायथन 3.3 पर चलता है। हालांकि, पहले संस्करणों के लिए, वही पायथन 2.7, उसी एपीआई का उपयोग करने का प्रस्ताव है, जीआईएल का व्यवहार स्वयं उतना महत्वपूर्ण नहीं है जितना कि उत्पन्न दुभाषिया से इसका प्रक्षेपण।
तो, चलिए शुरू करते हैं, हमें मुख्य धागे की आवश्यकता है, जिसमें हम सब कुछ शुरू करते हैं और निश्चित पायथन कार्यक्षमता के साथ काम करने वाले धागे की एक निश्चित संख्या को चलाते हैं, दोनों देशी पायथन और सी ++ में लिखे गए हैं। हम C ++ से सब कुछ करेंगे, हम बढ़ावा देने के साथ काम करेंगे :: अजगर और बढ़ावा :: धागा पुस्तकालय। यदि आपके पास अभी तक कोई BOOST लाइब्रेरी नहीं है, या यदि आप C ++ के बजाय शुद्ध C का उपयोग करते हैं, तो यह ठीक है, यहाँ मुख्य कार्य C में है, और BOOST का उपयोग केवल विज़ुअलाइज़ेशन और विकास में आसानी के लिए किया जाता है, सभी को Python API का उपयोग करके शुद्ध C में किया जा सकता है और थ्रेड्स के साथ काम करने के लिए ओएस एपीआई।
पायथन के साथ काम करने की शुरुआत में, आपको दुभाषिया को शुरू करने, जीआईएल तंत्र को सक्षम करने और जीआईएल में मल्टीथ्रेडिंग को सक्षम करने की आवश्यकता है, मुख्य थ्रेड की स्थिति को संरक्षित करते हुए:

Py_Initialize(); //   Python PyEval_InitThreads(); //    Python   GIL mGilState = PyGILState_Ensure(); //   GIL     mThreadState = PyEval_SaveThread(); //       GIL //  GIL     Python

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

  //  GIL       PyEval_RestoreThread( mThreadState ); //        GIL PyGILState_Release( mGilState ); //   GIL    Py_Finalize(); //     ,   - Python

अब तक, सब कुछ उन सभी के लिए स्पष्ट है, जिन्होंने कभी पायथन भाषा के C-API से GIL के साथ काम किया है। मुख्य सूत्र के लिए, आपको केवल GIL को अवरुद्ध किए बिना और शेष थ्रेड को अपना काम करने से रोकने के बिना एक डिस्पैचर के रूप में कार्य करने की आवश्यकता है। यह वही है जो पूरी कक्षा को दिखना चाहिए:

 class PyMainThread //      { public: PyMainThread() //         { Py_Initialize(); //   Python PyEval_InitThreads(); //    Python   GIL mGilState = PyGILState_Ensure(); //   GIL     mThreadState = PyEval_SaveThread(); //       GIL //  GIL     Python       } ~PyMainThread() //         { //  GIL       PyEval_RestoreThread( mThreadState ); //        GIL PyGILState_Release( mGilState ); //   GIL    Py_Finalize(); //     ,   - Python } private: PyGILState_STATE mGilState; //   GIL PyThreadState* mThreadState; //     };

दरअसल, मुख्य योजना () फ़ंक्शन या उसके एनालॉग में काम निम्न योजना के लिए आता है:

  PyMainThread main_thread; //       boost::thread_group group; //  ,    ,   Python   GIL for( int id = 1; id <= THREAD_NUM; ++id) group.create_thread( ThreadWork(id) ); group.join_all();

सब कुछ, आदिमवाद के साथ समाप्त, लोग जादू के लिए लंबे समय तक ... ओह हां, मैंने वादा किया था कि यह नहीं होगा।

हर सूत्र में काम करो

यदि हम प्रत्येक उत्पन्न धागे में सिर्फ time.sleep (1) करने की कोशिश करते हैं, तो हमें पहले से ही दूसरे धागे पर एक बूंद मिलेगी।
हम जादू के कार्य Py_NewInterpreter (!!!) द्वारा सहेजे जाएंगे, जिसमें सब कुछ ठीक होगा, लेकिन इसके उपयोग के लिए GIL (!) को लॉक करने की आवश्यकता होती है और यह डरावना होगा यदि यह इस तथ्य के लिए नहीं था कि GIL आता है और जाता है, लेकिन उप-दुभाषिया रहता है और इसमें पहले से ही आप अपनी जीआईएल को जितना चाहें ब्लॉक कर सकते हैं, इसके ठीक 1 धागे होंगे - जिस में इसे बनाया गया था:

  mMainGilState = PyGILState_Ensure(); //     mOldThreadState = PyThreadState_Get(); //      mNewThreadState = Py_NewInterpreter(); //    - PyThreadState_Swap( mNewThreadState ); //        - mSubThreadState = PyEval_SaveThread(); //      GIL mSubGilState = PyGILState_Ensure(); //   GIL   -

यह भी एक विशेष वर्ग के निर्माता में सबसे अच्छा किया जाता है, और निम्न कोड क्रमशः, विध्वंसक में:

  PyGILState_Release( mSubGilState ); //  GIL  - PyEval_RestoreThread( mSubThreadState ); //         Py_EndInterpreter( mNewThreadState ); //   - PyThreadState_Swap( mOldThreadState ); //       PyGILState_Release( mMainGilState ); //   GIL

पूरी कक्षा के लिए कोड नीचे दिखाया गया है:

 class PySubThread //        { public: PySubThread() //    - Python      { mMainGilState = PyGILState_Ensure(); //     mOldThreadState = PyThreadState_Get(); //      mNewThreadState = Py_NewInterpreter(); //    - PyThreadState_Swap( mNewThreadState ); //        - mSubThreadState = PyEval_SaveThread(); //      GIL mSubGilState = PyGILState_Ensure(); //   GIL   - } ~PySubThread() //         - Python { PyGILState_Release( mSubGilState ); //  GIL  - PyEval_RestoreThread( mSubThreadState ); //         Py_EndInterpreter( mNewThreadState ); //   - PyThreadState_Swap( mOldThreadState ); //       PyGILState_Release( mMainGilState ); //   GIL    } private: PyGILState_STATE mMainGilState; //  GIL   Python PyThreadState* mOldThreadState; //       PyThreadState* mNewThreadState; //     - PyThreadState* mSubThreadState; //      GIL PyGILState_STATE mSubGilState; //  GIL   - Python };

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

परिणाम का परीक्षण

तो आइए देखें कि हम कितने सही हैं। चलो हमारे पायथन मॉड्यूल को C ++ में लिखा गया है और समय के साथ एक फ़ंक्शन प्रदान करते हैं। सो:

 #include <boost/python.hpp> #include <boost/thread.hpp> using namespace boost::python; using namespace boost::this_thread; using namespace boost::posix_time; void wait( double sec ) //  ,   time.sleep  Python { int msec = static_cast<int>( sec * 1000 ); //    sleep( millisec( msec ) ); //      } BOOST_PYTHON_MODULE( ctimer ) //  boost::python    ctimer { def( "wait", wait, args("sec") ); //  Python   ctimer.wait(sec) }

अगर हम विंडोज पर हैं तो हम DLL को संकलित करते हैं और इसे ctimer.pyd नाम देते हैं। हम मुख्य एप्लिकेशन को निष्पादित करने के लिए परिणामस्वरूप ctimer मॉड्यूल जोड़ते हैं। हम मानक समय के साथ ctimer.wait का उपयोग करेंगे। सो जाओ।
हम प्रत्येक अलग थ्रेड में काम करने के लिए एक मज़ेदार वर्ग बनाते हैं:

 class ThreadWork //  -     boost::thread { public: ThreadWork( int id ) //      : mID( id ) { } void operator () ( void ) //       { cout << "Thread#" << mID << " <= START" << endl; PySubThread sub_thread; //    - Python for( int rep = 1; rep <= REPEAT_TIMES; ++rep ) { //      Python cout << "Thread#" << mID << " <= Repeat#" << rep << " <= import time; time.sleep(pause)" << endl; object time = import( "time" ); // import time time.attr( "sleep" )( PAUSE_SEC ); // time.sleep(pause) //      C++ cout << "Thread#" << mID << " <= Repeat#" << rep << " <= import ctimer; ctimer.wait(pause)" << endl; object ctimer = import( "ctimer" ); // import ctimer ctimer.attr( "wait" )( PAUSE_SEC ); // ctimer.wait(pause) } cout << "Thread#" << mID << " <= END" << endl; //  - Python    } private: int mID; //      };

एप्लिकेशन लॉन्च करें और आनंद लें! पायथन में मॉड्यूल के समानांतर थ्रेड्स काम करते हैं, प्रत्येक थ्रेड में अलग-अलग छोटे पॉड-पिचर्स होते हैं, जो उनके प्रत्येक जीआईएल को अवरुद्ध करते हैं और पूरी तरह से स्वतंत्र रूप से एक दूसरे के साथ हस्तक्षेप किए बिना काम करते हैं।
हुर्रे, कॉमरेड्स!

स्रोत कोड (दो संपूर्ण। Cpp फ़ाइलों) और संकलित DLL और EXEs के साथ MSVS 2012 परियोजना का लिंक Python 3.3 x64 के लिए यहां डाउनलोड किया जा सकता है (290 KB)

उपयोगी लिंक

पायथन उप-दुभाषिया के साथ काम करना
धागे, दुभाषिया और जीआईएल के साथ काम करने के लिए एपीआई
Boost.Python प्रलेखन
Boost.Thread प्रलेखन

एक मल्टीथ्रेडेड C ++ एप्लिकेशन में पायथन का उपयोग करना और पायथन में सच्चे मल्टीथ्रेडिंग का उपयोग करना

पायथन में ईमानदार बहुस्तरीयता

हर सूत्र में काम करो

परिणाम का परीक्षण

उपयोगी लिंक

More articles: