वर्कफ़्लो प्रबंधन: इंजन राज्य प्रबंधन

यह लेख लेख का एक निरंतरता है - कार्य प्रवाह का संगठन: सिंक्रनाइज़ेशन चैनल । अगली कड़ी को सिंक्रोनस संदेश दृष्टिकोण का उपयोग करने का एक उदाहरण लिखने के प्रयास के रूप में पैदा हुआ था।

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

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

सबसे पहले, चलिए इंजन राज्यों के एक सेट पर निर्णय लेते हैं। हमारा इंजन अतुल्यकालिक होगा, इसलिए राज्यों के सेट में संक्रमण राज्य भी होंगे। मुझे राज्यों का निम्नलिखित सेट मिला: NotStarted, StartPending, Started, PausePending, Paused, ResumePending, StopPending।

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

आइए देखें कि एक उदाहरण के रूप में संबंधित नियंत्रण बटन के साथ WTL संवाद का उपयोग करके इंजन की स्थिति में बदलाव के बारे में अधिसूचना का इंजन कैसा दिख सकता है:

void CMainDlg::OnStateChanged(EngineState::State state) { //    ,     GUI     CSyncChannel, //              //   Pending ,   ,       //          GetDlgItem(IDC_BUTTON_START).EnableWindow(FALSE); GetDlgItem(IDC_BUTTON_STOP).EnableWindow(FALSE); GetDlgItem(IDC_BUTTON_PAUSE).EnableWindow(FALSE); GetDlgItem(IDC_BUTTON_CONTINUE).EnableWindow(FALSE); switch (state) { case EngineState::NotStarted: GetDlgItem(IDC_BUTTON_START).EnableWindow(TRUE); break; case EngineState::Started: GetDlgItem(IDC_BUTTON_STOP).EnableWindow(TRUE); GetDlgItem(IDC_BUTTON_PAUSE).EnableWindow(TRUE); break; case EngineState::Paused: GetDlgItem(IDC_BUTTON_STOP).EnableWindow(TRUE); GetDlgItem(IDC_BUTTON_CONTINUE).EnableWindow(TRUE); break; } } 

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

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

स्टार्टपिंग जैसे लंबित राज्यों में संक्रमण, नियंत्रण कार्यों की कॉल के अंदर किया जाता है, जैसे स्टार्ट, और इसलिए, स्टार्ट फ़ंक्शन से बाहर निकलने के बाद, इंजन में स्टार्टपेंडिंग स्थिति होगी। यही है, StartPending राज्य में संक्रमण की एक अधिसूचना को सिंक्रोनस कहा जाएगा, भले ही प्रारंभ फ़ंक्शन को कॉल पूरा होने से पहले।

आइए इंजन के कार्यान्वयन को देखें।
मैं इंजन क्लास को पूरी तरह से लाता हूं, क्योंकि जब मल्टीथ्रेडिंग के साथ काम करते हैं, तो कोई भी लापता भाग एक बड़ी भूमिका निभा सकता है।

 //Engine.h namespace EngineState { enum State { NotStarted, StartPending, Started, PausePending, Paused, ResumePending, StopPending }; }; class IEngineEvents { public: virtual void OnStateChanged(EngineState::State state) = 0; }; class CEngine { public: CEngine(IEngineEvents* listener); ~CEngine(void); public: //      void Start(); void Stop(); void Pause(); void Resume(); public: // GUI          bool ProcessMessage(MSG& msg); private: void WaitForThread(); static DWORD WINAPI ThreadProc(LPVOID param); void Run(); bool CheckStopAndPause(); void ChangeState(EngineState::State state); void OnStateChanged(EngineState::State state); private: CSyncChannel m_syncChannel; //        IEngineEvents* m_listener; HANDLE m_hThread; volatile EngineState::State m_state; }; 

 // Engine.cpp CEngine::CEngine(IEngineEvents* listener) : m_listener(listener), m_hThread(NULL), m_state(EngineState::NotStarted) { m_syncChannel.Create(GetCurrentThreadId()); } CEngine::~CEngine(void) { //      ,      m_state = EngineState::StopPending; //  ,    . //          GUI,   . //  ,       , //  m_syncChannel,      . m_syncChannel.Close(); //     . WaitForThread(); } void CEngine::WaitForThread() { if (m_hThread) { //    . //         : // StopPending  NotStarted _ASSERT(m_state == EngineState::StopPending || m_state == EngineState::NotStarted); //      DWORD waitResult = WaitForSingleObject(m_hThread, INFINITE); _ASSERT(waitResult == WAIT_OBJECT_0); //    ,    HANDLE   CloseHandle(m_hThread); m_hThread = NULL; } } void CEngine::Start() { //   ,   GUI  //        ,      //      if (m_state == EngineState::NotStarted) { //   Start   ,    , //         //       ,     WaitForThread(); //    , //   this,      Run    m_hThread = CreateThread(NULL, 0, CEngine::ThreadProc, this, 0, NULL); if (m_hThread) { //     StartPending //       ChangeState(EngineState::Started) //  ,      SyncChannel, //       , //    ,        "Start" //     StartPending    , //    Started    ChangeState(EngineState::StartPending); } } } void CEngine::Stop() { //   ,   GUI  if (m_state != EngineState::NotStarted && m_state != EngineState::StopPending) { //   ,          ChangeState(EngineState::StopPending); } //    ,     //      //       ChangeState(EngineState::Stopped) //         WaitForThread } void CEngine::Pause() { //   ,   GUI  if (m_state == EngineState::Started) { //    PausePending     Started ChangeState(EngineState::PausePending); } } void CEngine::Resume() { //   ,   GUI  if (m_state == EngineState::Paused) { //    ResumePending     Paused ChangeState(EngineState::ResumePending); } } bool CEngine::ProcessMessage(MSG& msg) { // GUI         return m_syncChannel.ProcessMessage(msg); } DWORD WINAPI CEngine::ThreadProc(LPVOID param) { //    ,   //        Run reinterpret_cast<CEngine*>(param)->Run(); return 0; } void CEngine::Run() { //  GUI  ,     ChangeState(EngineState::Started); for (;;) { //    ,   -  //          if (!CheckStopAndPause()) { break; } //    -  ,    :) Sleep(1000); } //   ,     ChangeState(EngineState::NotStarted); //     NotStarted   //  -        //        WaitForSingleObject } bool CEngine::CheckStopAndPause() { //       . //        GUI. if (m_state == EngineState::StopPending) { //    Stop,     return false; } if (m_state == EngineState::PausePending) { //     , //    GUI     //        ChangeState(EngineState::Paused); while (m_state == EngineState::Paused) { Sleep(100); } if (m_state == EngineState::StopPending) { //    Stop,     return false; } //      //    GUI         ChangeState(EngineState::Started); } //       return true; } void CEngine::ChangeState(EngineState::State state) { //       , //    GUI ,  m_syncChannel m_syncChannel.Execute(boost::bind(&CEngine::OnStateChanged, this, state)); } void CEngine::OnStateChanged(EngineState::State state) { //      GUI ,   m_state //     m_state       //      ,       //             GUI  m_state = state; m_listener->OnStateChanged(m_state); } 

CEngine वर्ग का उपयोग करना।
मेरे उदाहरण में, क्लास CEngine की एक वस्तु को संवाद के WTL वर्ग का सदस्य घोषित किया गया है।
प्रारंभ, स्टॉप, कंटिन्यू, और पॉज़ कीज़ को दबाने के लिए हैंडलर को संवाद फ़ंक्शंस का सेट कम किया जाता है जो कि CEngine ऑब्जेक्ट के संबंधित फ़ंक्शन को फिर से कॉल करते हैं।

इसके अलावा, संवाद वर्ग IEngineEvents इंटरफ़ेस का उपयोग करके इंजन की स्थिति में परिवर्तन की सूचनाओं की सदस्यता लेता है, इस इंटरफ़ेस के OnStateChanged फ़ंक्शन का कार्यान्वयन लेख की शुरुआत में दिया गया था।

यह सुनिश्चित करने के लिए कि स्ट्रीम संदेश CEngine वर्ग में अनुवादित हैं, संवाद वर्ग मानक विधियों WTL :: CMessageLoop :: AddMessageFilter का उपयोग करके एक विंडो संदेश फ़िल्टर के रूप में सेट होता है, और WTL :: CMessageililter इंटरफ़ेस लागू करता है:

 class CMessageFilter { public: virtual BOOL PreTranslateMessage(MSG* pMsg) = 0; }; 

PreTranslateMessage फ़ंक्शन का कार्यान्वयन CEngine :: ProcessMessage फ़ंक्शन की पुन: कॉल के लिए आता है

आवेदन को बंद करते समय प्रवाह के आपसी अवरोध की समस्या को हल करने के लिए, संवाद वर्ग में कोई अतिरिक्त कार्रवाई की आवश्यकता नहीं होती है। इस समस्या को पूरी तरह से CSyncChannel का उपयोग करके हल किया गया है :: CEngine वर्ग विध्वंसक में बंद। इस प्रकार, वर्कफ़्लो पूरी तरह से CEngine वर्ग के अंदर समझाया जाता है, जो इस तरह के वर्ग के साथ काम करते समय मूर्त लाभ देता है।