Qt पर एकल उदाहरण अनुप्रयोग

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

- QSystemSemaphore वर्ग का एक उदाहरण बनाएं, यह एक वैश्विक (सिस्टम) सेमाफोर बनाता है
- कॉल acquire करें, एक से सेमीफोर काउंटर को कम करें
- कुछ करो
- कॉल release , एक से सेमीफोर काउंटर बढ़ाएँ

सामान्य तौर पर, शास्त्रीय सेमाफोर, केवल वैश्विक। यह स्पष्ट है कि यदि आप 1 के बराबर काउंटर के प्रारंभिक मूल्य के साथ एक सेमाफोर बनाते हैं और acquire कॉल करते हैं, तो जब तक हम release नहीं बुलाते हैं तब तक कोई और इस सेमाफोर पर कब्जा नहीं कर सकता है। हुर्रे, समाधान मिला! एकल-उदाहरण अनुप्रयोग का निम्न कोड तुरंत निकलता है:

- एक सेमाफोर बनाएं
- हड़पना
- आवेदन काम करता है
- शट डाउन करने के बाद, एप्लिकेशन सेमीफोर जारी करता है

सब कुछ बढ़िया है, सब कुछ ठीक है। प्रलेखन हमसे वादा करता है कि भले ही आप release कॉल न करें (उदाहरण के लिए, प्रोग्राम क्रैश हो गया), सिस्टम अभी भी सभी यूनिटों पर कब्जा किए गए सेमीफ़ायर पर वापस आ जाएगा। लेकिन एक समस्या है। यदि उपयोगकर्ता एप्लिकेशन का दूसरा उदाहरण शुरू करता है, तो उसे इसके बारे में कैसे पता चलेगा? acquire विधि के लिए कॉल अवरुद्ध है और जब तक सेमाफ़ोर को मुक्त नहीं किया जाता है, तब तक आवेदन "लटका" होगा, और उपयोगकर्ता अविश्वास में कुछ इंतजार करेगा।

यह प्रतीत होता है - एक समस्या नहीं है। उदाहरण के लिए, एक ही QMutex म्यूटेक्स पर कब्जा करने के लिए lock कॉल के अलावा, कॉल और try_lock को गैर-ब्लॉक करने के प्रयास को कैप्चर करने के लिए है। सिस्टम सेमाफोर के लिए भी कुछ ऐसा ही होना चाहिए। लेकिन - अफसोस - वह नहीं है। मैं लंबे समय तक असफल रहा और असफल रहा - मंच समान विषयों से भरा हुआ है और एक भी काम करने वाला समाधान नहीं है। एक समस्या है? समस्या। दिलचस्प? बहुत। मैंने इसे हल करने का बीड़ा उठाया।

एक QSystemSemaphore साथ QSystemSemaphore स्पष्ट रूप से कुछ भी हल नहीं किया जाएगा। वैश्विक स्तर पर Qt में और क्या है? QSharedMemory । विभिन्न अनुप्रयोगों के बीच साझा की गई स्मृति। यह इस तरह काम करता है:

- QSharedMemory वर्ग का एक उदाहरण बनाएँ
- पहले से बनाई गई मेमोरी से कनेक्ट करने के लिए कॉल attach
- यदि कनेक्शन विफल हो गया, तो हम साझा मेमोरी create लिए कॉल करते create
- हम साझा मेमोरी के साथ काम करते हैं (उदाहरण के लिए, हम कुछ डेटा को दूसरी प्रक्रिया में स्थानांतरित करते हैं)
- विध्वंसक खुद को साझा मेमोरी से detach और detach बुलाता है

यह प्रतीत होता है - यहाँ यह है! यदि attach कॉल सफल है, तो एप्लिकेशन पहले से चल रहा है। यदि नहीं, तो एप्लिकेशन पहली बार लॉन्च किया गया है, हम कॉल create और इस प्रकार, हम साझा मेमोरी के स्वामित्व के मामले में हमारी प्रधानता को समेकित करते हैं (अर्थात, अन्य सभी के लिए, attach पहले से ही सफल होगा)। यहां वास्तव में दो समस्याएं हैं।

पहला रेसिंग है। दो प्रक्रियाएं एक साथ attach हो सकती attach , विफल हो सकती हैं, दोनों मान लेंगे कि वे पहले और चालान create । एक स्मृति बनाएगा, दूसरा विफल हो जाएगा। अच्छा नहीं है, लेकिन, सामान्य रूप से, सहिष्णु। आप आसपास पहुँच सकते हैं।

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

इस प्रकार, हमारे पास दो वर्ग हैं - QSystemSemaphore और QSharedMemory , जिनमें से प्रत्येक आंशिक रूप से आवश्यक कार्यक्षमता को लागू करता है, लेकिन अंतिम कार्य को हल नहीं करता है। शायद इन दोनों "सामंजस्य" को सामंजस्यपूर्ण रूप से संयोजित करना संभव होगा?

और हाँ! QSystemSemaphore पहले QSharedMemory समस्या, रेसिंग समस्या को हल करता है। कोड:

 QSystemSemaphore sema("<Unique name1>", 1); bool isRunning; sema.acquire(); QSharedMemory shmem("<Unique name2>"); if (shmem.attach()) { isRunning = true; } else { shmem.create(1); isRunning = false; } sema.release(); 

सीधे शब्दों में कहें, एक वैश्विक सेमाफोर साझा मेमोरी प्रबंधन को सिंक्रनाइज़ करता है। जैसा कि वे कहते हैं, प्राथमिक, वाटसन।

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

अंतिम कोड इस तरह दिखता है:

 QSystemSemaphore sema("<Unique name1>", 1); bool isRunning; sema.acquire(); { QSharedMemory shmem("<Unique name2>"); shmem.attach(); } QSharedMemory shmem("<Unique name2>"); if (shmem.attach()) { isRunning = true; } else { shmem.create(1); isRunning = false; } sema.release(); 

यह स्पष्ट है कि QSharedMemory वर्ग का दूसरा उदाहरण आवेदन के अंत तक संरक्षित किया QSharedMemory चाहिए। और फिर सब कुछ ठीक वैसा ही काम करता है, जैसा होना चाहिए।