🐀 🧘🏼 🧑🏻 Qt-async अतुल्यकालिक विजेट लाइब्रेरी 🚬 📮 🙍🏻

सभी को शुभ दिन। मैं अपने qt-async प्रोजेक्ट के बारे में थोड़ी बात करना चाहता हूं, हो सकता है कि यह किसी को दिलचस्प या उपयोगी भी लगे।

डेवलपर्स के रोजमर्रा के जीवन में एसिंक्रोनसी और मल्टीथ्रेडिंग को गंभीरता से शामिल किया गया है। कई आधुनिक भाषाओं और पुस्तकालयों को अतुल्यकालिक उपयोग को ध्यान में रखकर बनाया गया है। C ++ भाषा भी धीरे-धीरे इस दिशा में आगे बढ़ रही है - std :: thread, std :: वादा / भविष्य दिखाई दिया है, वे coroutines और नेटवर्किंग में लाने वाले हैं। क्यूटी लाइब्रेरी भी पीछे नहीं रहती है, इसके एनालॉग्स क्यूथ्रेड, क्यूआरन्यूनेबल, क्यूथ्रेडपूल, क्यूफ्यूवन इत्यादि की पेशकश करती है। उसी समय, मुझे Qt में एसिंक्रोनस क्रियाओं को प्रदर्शित करने के लिए विगेट्स नहीं मिला (शायद मैं बुरी तरह से सही दिख रहा था, अगर मैं गलत हूं तो सही)।

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

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

इस प्रकार, हमारा मॉडल तीन राज्यों में से एक में हो सकता है:

प्रगति - एक अतुल्यकालिक ऑपरेशन जारी है
त्रुटि - एसिंक्रोनस ऑपरेशन विफल
मान - एसिंक्रोनस ऑपरेशन सफलतापूर्वक पूरा हुआ

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

एसिंक्रोनस ऑपरेशन की शुरुआत में, AsuncValue को प्रगति पर सेट करें
अंत में - या तो त्रुटि या मूल्य में, ऑपरेशन की सफलता पर निर्भर करता है
वैकल्पिक रूप से, ऑपरेशन के दौरान, आप प्रगति डेटा को अपडेट कर सकते हैं और स्टॉप फ्लैग को सुन सकते हैं यदि उपयोगकर्ता के पास ऑपरेशन को रोकने का अवसर है।

यहाँ एक योजनाबद्ध उदाहरण का उपयोग कर QRunnable है:

class MyRunnable : public QRunnable { public: MyRunnable(AsyncValue& value) : m_value(value) {} void run() final { m_value.setProgress(...); // do calculation if (success) m_value.setValue(...); else m_value.setError(...); } private: AsyncValue& m_value; }

Std के साथ काम करने के लिए एक ही योजना :: धागा:

 AsyncValue value; std::thread thread([&value] () { value.setProgress(...); // do calculation if (success) value.setValue(...); else value.setError(...); });

इस प्रकार, हमारी कक्षा का पहला संस्करण कुछ इस तरह दिख सकता है:

 template <typename ValueType_t, typename ErrorType_t, typename ProgressType_t> class AsyncValue { public: using ValueType = ValueType_t; using ErrorType = ErrorType_t; using ProgressType = ProgressType_t; // public API private: QReadWriteLock m_lock; std::variant<ValueType, ErrorType, ProgressType> m_value; };

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

AsyncValue वर्ग के उपयोगकर्ता वर्ग डेटा तक पहुँचने में सक्षम होना चाहिए। डेटा की एक प्रति जारी करना महंगा हो सकता है, किसी भी प्रकार ValueType / ErrorType / ProgressType भारी हो सकता है। आंतरिक डेटा का लिंक जारी करना खतरनाक है - किसी भी समय यह अमान्य हो सकता है। निम्नलिखित समाधान प्रस्तावित है:

1. फ़ंक्शंस एक्सेस के माध्यम से डेटा तक पहुँच प्रदान करें Access / AccessError / accessProgress, जिसमें lambdas प्राप्त होते हैं जो संबंधित डेटा प्राप्त करते हैं। उदाहरण के लिए:

 template <typename Pred> bool accessValue(Pred valuePred) { QReadLocker locker(&m_lock); if (m_value.index() != 0) return false; valuePred(std::get<0>(m_value)); return true; }

इस प्रकार, आंतरिक मूल्य का उपयोग संदर्भ द्वारा किया जाता है और पढ़ने के लिए लॉक के तहत होता है। यानी, एक्सेस के समय लिंक अमान्य नहीं होगा।

2. एक्सेस डेटा फ़ंक्शन में AsyncValue उपयोगकर्ता आंतरिक डेटा के लिंक को याद रख सकता है, बशर्ते कि वह राजकीय संकेत के लिए सदस्यता लिया हो और प्रसंस्करण के बाद संकेत को इस लिंक का उपयोग नहीं करना चाहिए, क्योंकि वह अमान्य हो जाएगा।

ऐसी शर्तों के तहत, AsyncValue उपभोक्ता को हमेशा वैध और सुविधाजनक डेटा एक्सेस की गारंटी दी जाती है। इस समाधान के कई परिणाम हैं जो AsyncValue वर्ग के कार्यान्वयन को प्रभावित करते हैं।

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

 lass AsyncValueBase : public QObject { Q_OBJECT Q_DISABLE_COPY(AsyncValueBase) signals: void stateChanged(); };

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

यह पता चला है कि एसटीडी :: संस्करण हमारे लिए उपयुक्त नहीं है और हमें गतिशील मेमोरी में डेटा स्टोर करना होगा ताकि नए और पुराने डेटा के पते अपरिवर्तित रहें।

एक छोटा सा विषयांतर।

आप AsyncValue वर्ग के अन्य कार्यान्वयन पर विचार कर सकते हैं जिन्हें गतिशील आवंटन की आवश्यकता नहीं है:

उपभोक्ताओं को केवल AsyncValue आंतरिक डेटा की प्रतियां दें। जैसा कि मैंने पहले लिखा था, यदि डेटा बड़ा है तो ऐसा समाधान अधिक उप-रूपी हो सकता है।
एक के बजाय दो संकेतों को परिभाषित करें: StateWillChange / stateDidChange। पहले संकेत पर पुराने लिंक से छुटकारा पाने के लिए उपभोक्ताओं को उपकृत करना और दूसरे सिग्नल पर नए लिंक प्राप्त करना। यह योजना, मुझे ऐसा लगता है, क्योंकि AsyncValue उपभोक्ताओं को अत्यधिक परेशान करता है, क्योंकि जब AsyncValue तक पहुँच से वंचित किया जाता है तो उनके पास समय अंतराल होता है।

सेटवैल्यू फंक्शन का निम्नलिखित योजनाबद्ध कार्यान्वयन प्राप्त किया जाता है:

 void AsyncValue::setValue(...) {  m_lock            {   m_lock          m_lock   }  stateChanged       m_lock   };

जैसा कि आप देख सकते हैं, हमें लिखने के लिए m_lock लॉक को बढ़ाने और इसे पढ़ने के लिए वापस करने की आवश्यकता है। दुर्भाग्य से, QReadWriteLock वर्ग में ऐसा कोई समर्थन नहीं है। आप QMutex / QReadWriteLock की एक जोड़ी के साथ वांछित कार्यक्षमता प्राप्त कर सकते हैं। यहाँ AsyncValue वर्ग का कार्यान्वयन है, जो वास्तविक के करीब है:

 //   AsyncValue enum class ASYNC_VALUE_STATE { VALUE, ERROR, PROGRESS }; Q_DECLARE_METATYPE(ASYNC_VALUE_STATE); //        class AsyncValueBase : public QObject { Q_OBJECT Q_DISABLE_COPY(AsyncValueBase) signals: void stateChanged(ASYNC_VALUE_STATE state); protected: explicit AsyncValueBase(ASYNC_VALUE_STATE state, QObject* parent = nullptr); //     PromoteToWriteLock/DemoteToReadLock QMutex m_writeLock; QReadWriteLock m_contentLock; //   ASYNC_VALUE_STATE m_state; }; template <typename ValueType_t, typename ErrorType_t, typename ProgressType_t> class AsyncValueTemplate : public AsyncValueBase { //  struct Content { std::unique_ptr<ValueType_t> value; std::unique_ptr<ErrorType_t> error; std::unique_ptr<ProgressType+t> progress; }; Content m_content; public: using ValueType = ValueType_t; using ErrorType = ErrorType_t; using ProgressType = ProgressType_t; //    template <typename... Args> void emplaceValue(Args&& ...arguments) { moveValue(std::make_unique<ValueType>(std::forward<Args>(arguments)...)); } //    void moveValue(std::unique_ptr<ValueType> value) { //       Content oldContent; //   emplaceXXX/moveXXX    QMutexLocker writeLocker(&m_writeLock); { //       QWriteLocker locker(&m_contentLock); //      oldContent = std::move(m_content); //    m_content.value = std::move(value); //    m_state = ASYNC_VALUE_STATE::VALUE; //     } //   emitStateChanged(); //    emplaceXXX/moveXXX  //    } //   value void emplaceError(Args&& ...arguments); void moveError(std::unique_ptr<ErrorType> error); void emplaceProgress(Args&& ...arguments); void moveProgress(std::unique_ptr<ProgressType> progress); template <typename Pred> bool accessValue(Pred valuePred) { //     QReadLocker locker(&m_contentLock); //    if (m_state != ASYNC_VALUE_STATE::VALUE) return false; //      valuePred(*m_content.value); //     return true; } //  accessValue bool accessError(Pred errorPred) bool accessProgress(Pred progressPred) };

उन लोगों के लिए जो थके हुए और खोए नहीं हैं, हम जारी रखते हैं।

जैसा कि आप देख सकते हैं, हमारे पास एक्सेसएक्सएक्सएक्स फ़ंक्शन हैं जो तब तक इंतजार नहीं करते हैं जब तक कि असिंकवैल्यू संबंधित स्थिति में प्रवेश नहीं करता है, लेकिन बस झूठे वापस आ जाता है। यह कभी-कभी उपयोगी रूप से तब तक प्रतीक्षा करने के लिए उपयोगी होता है जब तक कि AsyncValue में कोई मान या त्रुटि दिखाई न दे। अनिवार्य रूप से, हमें std :: future :: get का एनालॉग चाहिए। यहाँ फ़ंक्शन हस्ताक्षर है:

 template <typename ValuePred, typename ErrorPred> void wait(ValuePred valuePred, ErrorPred errorPred);

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

एक अन्य फ़ील्ड को AsyncValue वर्ग में जोड़ना, जो कि दुर्लभ मामलों में आवश्यक है जब प्रतीक्षा फ़ंक्शन का उपयोग किया जाता है, मुझे सोचने के लिए प्रेरित किया है - क्या इस क्षेत्र को वैकल्पिक बनाया जा सकता है? उत्तर स्पष्ट है, निश्चित रूप से यह संभव है यदि आप std :: unique_ptr स्टोर करते हैं और यदि आवश्यक हो तो इसे बनाते हैं। दूसरा सवाल सामने आया - क्या इस क्षेत्र को वैकल्पिक बनाना संभव है और न कि गतिशील आवंटन करना। कौन परवाह करता है, कृपया निम्नलिखित कोड देखें। मुख्य विचार निम्नानुसार है: पहला प्रतीक्षा कॉल स्टैक पर एक QWaitCondition संरचना बनाता है और अपने पॉइंटर को AsyncValue पर लिखता है, बाद में प्रतीक्षा कॉल की जाँच करता है कि क्या पॉइंटर खाली नहीं है, इस पॉइंटर द्वारा संरचना का उपयोग करें, यदि पॉइंटर खाली है, तो पहले प्रतीक्षा कॉल के लिए ऊपर देखें। ।

 class AsyncValueBase : public QObject { ... struct Waiter { //     QWaitCondition waitValue; //   wait quint16 subWaiters = 0; //  wait     QWaitCondition waitSubWaiters; }; //    Waiter* m_waiter = nullptr; }; template <typename ValuePred, typename ErrorPred> void wait(ValuePred valuePred, ErrorPred errorPred) { //   -      if (access(valuePred, errorPred)) return; //  AsyncValue   QMutexLocker writeLocker(&m_writeLock); //     if (access(valuePred, errorPred)) return; //    wait  if (!m_waiter) { //  Waiter   Waiter theWaiter; //       if SCOPE_EXIT { //     wait, //    theWaiter if (m_waiter->subWaiters > 0) { //    subWaiters   do { m_waiter->waitSubWaiters.wait(&m_writeLock); } while (m_waiter->subWaiters != 0); } //   wait  , //       Waiter m_waiter = nullptr; }; //    Waiter  AsyncValue //    wait   m_waiter = &theWaiter; //   AsyncValue     Value  Error //    do { m_waiter->waitValue.wait(&m_writeLock); } while (!access(valuePred, errorPred)); } //   wait   else { //       else SCOPE_EXIT { //      m_waiter->subWaiters -= 1; //     ->   wait if (m_waiter->subWaiters == 0) m_waiter->waitSubWaiters.wakeAll(); }; //      m_waiter->subWaiters += 1; //   AsyncValue     Value  Error //    do { m_waiter->waitValue.wait(&m_writeLock); } while (!access(valuePred, errorPred)); } }

जैसा कि पहले ही उल्लेख किया गया है, AsyncValue में अतुल्यकालिक कंप्यूटिंग के लिए एक विधि नहीं है ताकि एक विशिष्ट पुस्तकालय के लिए बाध्य न हो। इसके बजाय, नि: शुल्क फ़ंक्शंस का उपयोग किया जाता है जो एक तरह से या किसी अन्य में अतुल्यकालिक को लागू करते हैं। निम्नलिखित थ्रेड पूल पर AsyncValue कंप्यूटिंग का एक उदाहरण है:

 template <typename AsyncValueType, typename Func, typename... ProgressArgs> bool asyncValueRunThreadPool(QThreadPool *pool, AsyncValueType& value, Func&& func, ProgressArgs&& ...progressArgs) { //    auto progress = std::make_unique<typename AsyncValueType::ProgressType>(std::forward<ProgressArgs>(progressArgs)...); //    auto progressPtr = progress.get(); //    AsyncValue if (!value.startProgress(std::move(progress))) return false; QtConcurrent::run(pool, [&value, progressPtr, func = std::forward<Func>(func)](){ SCOPE_EXIT { //     AsyncValue,    value.completeProgress(progressPtr); }; //  AsyncValue func(*progressPtr, value); }); return true; }

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

सुरक्षा बढ़ाने के लिए, AsyncValue वर्ग को अन्य AsyncTrackErrorsPolicy टेम्पलेट वर्ग के साथ विस्तारित किया गया है, जो आपको AsyncValue के दुरुपयोग का जवाब देने की अनुमति देता है। उदाहरण के लिए, यहां AsyncTrackErrorsPolicy :: inProgressWhileDestruct फ़ंक्शन का डिफ़ॉल्ट कार्यान्वयन है, जिसे एसिंक्रोनस ऑपरेशन चलने के दौरान AsyncValue नष्ट होने पर कहा जाएगा:

  void inProgressWhileDestruct() const { Q_ASSERT(false && "Destructing value while it's in progress"); }

विगेट्स के लिए, उनका कार्यान्वयन काफी सरल और संक्षिप्त है। AsyncWidget एक कंटेनर है जिसमें एक त्रुटि, या प्रगति प्रदर्शित करने के लिए एक विजेट होता है, या वर्तमान में AsyncValue किस स्थिति के आधार पर एक मूल्य है।

  virtual QWidget* createValueWidgetImpl(ValueType& value, QWidget* parent); virtual QWidget* createErrorWidgetImpl(ErrorType& error, QWidget* parent); virtual QWidget* createProgressWidgetImpl(ProgressType& progress, QWidget* parent);

उपयोगकर्ता केवल पहले फ़ंक्शन को फिर से परिभाषित करने के लिए बाध्य है, मूल्य प्रदर्शित करने के लिए, अन्य दो में डिफ़ॉल्ट कार्यान्वयन हैं।

Qt-async लाइब्रेरी कॉम्पैक्ट हो गई है, लेकिन एक ही समय में काफी उपयोगी है। AsyncValue / AsyncWidget का उपयोग करना, जहां पहले सिंक्रोनस फ़ंक्शंस और एक स्थिर GUI थे, आपके एप्लिकेशन को आधुनिक और अधिक संवेदनशील बनने की अनुमति देगा।

उन लोगों के लिए जिन्होंने बोनस को अंत तक पढ़ा है - डेमो एप्लिकेशन का एक वीडियो

Qt-async अतुल्यकालिक विजेट लाइब्रेरी

More articles: