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

संकेतों के बारे में महत्वपूर्ण तथ्य:

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

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

सिग्नल हैंडलर फ़ंक्शन

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

void hdl(int sig) { exit = true; } 

नया सिग्नल प्रोसेसर स्थापित करने के लिए दो कार्य हैं।

 sighandler_t signal(int signum, sighandler_t handler); 

जो सिग्नल नंबर, फ़ंक्शन हैंडलर के लिए एक संकेतक (या SIG_IGN (सिग्नल को अनदेखा करें) या SIG_DFL (डिफ़ॉल्ट हैंडलर)) लेता है, और पुराने हैंडलर को लौटाता है। SIGKILL और SIGSTOP सिग्नल "इंटरसेप्टेड" या अनदेखा नहीं किया जा सकता है। इस फ़ंक्शन का उपयोग करना बहुत हतोत्साहित करता है क्योंकि:

• फ़ंक्शन वर्तमान सिग्नल को चलाने के दौरान अन्य सिग्नल प्राप्त करने को अवरुद्ध नहीं करता है, यह बाधित हो जाएगा और एक नया हैंडलर शुरू होगा
• सिग्नल की पहली प्राप्ति के बाद (जिसके लिए हम अपना हैंडलर सेट करते हैं), इसके हैंडलर को SIG_DFL में रीसेट कर दिया जाएगा

समारोह में इन कमियों का अभाव है

 int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); 

जो एक संकेत संख्या (SIGKILL और SIGSTOP को छोड़कर) को भी स्वीकार करता है। दूसरा तर्क सिग्नल के लिए एक नया विवरण है, तीसरा मान पुराना मान लौटाता है। स्ट्रक्चर सिगनेशन स्ट्रक्चर हमारे लिए निम्न रुचि के क्षेत्र हैं।

• sa_handler - संकेत समारोह में sighandler_t के समान
• sa_mask - संकेतों का मुखौटा जो अवरुद्ध हो जाएगा जबकि हमारा हैंडलर चल रहा है। + डिफ़ॉल्ट रूप से, प्राप्त संकेत स्वयं अवरुद्ध है
• sa_flags - आपको सिग्नल को संसाधित करते समय अतिरिक्त क्रियाएं सेट करने की अनुमति देता है जो यहां के बारे में पढ़ने के लिए बेहतर हैं

इस फ़ंक्शन का उपयोग करना काफी सरल लगता है।

 struct sigaction act; memset(&act, 0, sizeof(act)); act.sa_handler = hdl; sigset_t set; sigemptyset(&set); sigaddset(&set, SIGUSR1); sigaddset(&set, SIGUSR2); act.sa_mask = set; sigaction(SIGUSR1, &act, 0); sigaction(SIGUSR2, &act, 0); 

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

सिग्नल ब्लॉक करना

किसी प्रक्रिया के लिए कुछ संकेतों को अवरुद्ध करने के लिए, आपको उन्हें इस प्रक्रिया के सिग्नल मास्क में जोड़ना होगा। ऐसा करने के लिए, फ़ंक्शन का उपयोग करें

 int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); 

हम मौजूदा सिग्नल मास्क में नए सिग्नल (SIG_BLOCK) जोड़ सकते हैं, हम इस मास्क से सिग्नल (SIG_UNBLOCK) का हिस्सा निकाल सकते हैं, और हमारे सिग्नल मास्क (SIG_SETMASK) को भी पूरी तरह से सेट कर सकते हैं।
थ्रेड के अंदर सिग्नल मास्क के साथ काम करने के लिए, फ़ंक्शन का उपयोग करें

 int pthread_sigmask(int how, const sigset_t *set, sigset_t *oset); 

जो आपको सब कुछ करने की अनुमति देता है, लेकिन प्रत्येक धागे के लिए व्यक्तिगत रूप से।
आप इन कार्यों के साथ SIGKILL या SIGSTOP सिग्नल को ब्लॉक नहीं कर सकते। ऐसा करने के प्रयासों को नजरअंदाज किया जाएगा।

sigwait

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

संकेत भेजना

किसी प्रक्रिया को संकेत भेजने के लिए, दो कार्यों का उपयोग किया जा सकता है।

 int kill(pid_t pid, int sig); int raise(int sig); 

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

 int pthread_kill(pthread_t thread, int sig); 

संकेत उपयोग उदाहरण

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

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

 void* blocking_read(void* arg) { if(stop) { //   ,     ? std::cout << "Thread was aborted\n"; pthread_exit((void *)0); } //   SIGINT sigset_t set, orig; sigemptyset(&set); sigaddset(&set, SIGINT); sigemptyset(&orig); pthread_sigmask(SIG_BLOCK, &set, &orig); if(stop) { //         //       std::cout << "Thread was aborted\n"; pthread_sigmask(SIG_SETMASK, &orig, 0); pthread_exit((void *)0); } //       SIGINT std::cout << "Start thread to blocking read\n"; // ... // ,  ,    ppoll ppoll((struct pollfd*) &clients, 1, NULL, &orig); if(stop) { //      std::cout << "Thread was aborted\n"; close(sockfd); pthread_sigmask(SIG_SETMASK, &orig, 0); //   SIGINT    } //    ,    .     //        " " close(sockfd); pthread_exit((void *)0); } 

स्टॉप एक वैश्विक बुलियन ध्वज है जो हमारे हैंडलर द्वारा सही पर सेट किया गया है , जो धागे को बाहर निकलने के लिए कहता है।
काम का तर्क यह है:

• हम जाँचते हैं कि जब धागा शुरू हुआ था, तब वे इसे पूरा नहीं करना चाहते थे
• फाइनल सिग्नल को ब्लॉक करें
• हम जांचते हैं कि जब वे हमें रोक रहे थे, तो वे हमें पूरा नहीं करना चाहते थे
• हम ppoll को अंतिम पैरामीटर के रूप में एक सिग्नल मास्क कहते हैं जिसके द्वारा एक सिग्नल की उम्मीद की जाती है
• ppoll से बाहर निकलने के बाद, हम जांचते हैं कि वे पूर्ण होने के संकेत के कारण नहीं हैं

यहाँ मुख्य कार्य है

 int main() { ... struct sigaction act; memset(&act, 0, sizeof(act)); act.sa_handler = hdl; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask, SIGINT); sigaction(SIGINT, &act, 0); ... pthread_kill(th1, SIGINT); ... } 

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

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

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

---

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