लिनक्स प्रोग्राम को एक से अधिक बार चलने से कैसे रोकें?

Question

लिनक्स प्रोग्राम/डिमन को किसी दिए गए समय में एक से अधिक बार निष्पादित करने से रोकने का सबसे अच्छा तरीका क्या है?

Answer 1

पीआईडी ​​फ़ाइल बनाने का सबसे आम तरीका है: एक स्थान परिभाषित करें जहां फ़ाइल जाएगी (अंदर/var/run सामान्य है)। सफल स्टार्टअप पर, आप इस फ़ाइल में अपना पीआईडी ​​लिखेंगे। यह तय करते समय कि क्या शुरू करना है, फ़ाइल को पढ़ें और यह सुनिश्चित करने के लिए जांचें कि संदर्भित प्रक्रिया मौजूद नहीं है (या यदि ऐसा होता है, तो यह आपके डिमन का उदाहरण नहीं है: लिनक्स पर, आप /proc/$PID/exe देख सकते हैं)। शटडाउन पर, आप फ़ाइल को हटा सकते हैं लेकिन यह कड़ाई से जरूरी नहीं है।

आपको ऐसा करने में मदद करने के लिए स्क्रिप्ट हैं, आपको start-stop-daemon उपयोगी होने के लिए मिल सकता है: यह पीआईडी ​​फाइलों का उपयोग कर सकता है या यहां तक ​​कि केवल निष्पादन योग्य के अस्तित्व के लिए वैश्विक रूप से जांच सकता है। यह इस कार्य के लिए ठीक से डिजाइन किया गया है और लोगों को इसे सही करने में मदद करने के लिए लिखा गया था।

Answer 2

आप कोड के लिए उपयोग है (अर्थात यह लिख रहे हैं):

• एक अस्थायी फ़ाइल बनाने, यह ताला, जब किया निकालने के लिए, return 1; यदि फ़ाइल मौजूद है, या,
• सूची प्रक्रियाओं, return 1; यदि प्रक्रिया नाम सूची

में है ऐसा न करने पर:

• मूल्य बना ई प्रोग्राम के लिए लॉन्चर रैपर जो उपर्युक्त

Answer 3

मुझे नहीं पता कि आपकी सटीक आवश्यकता क्या है लेकिन मुझे एक समान आवश्यकता थी; उस स्थिति में मैंने शैल स्क्रिप्ट से अपना डिमन शुरू किया (यह एक एचपी-यूएक्स मशीन थी) और डेमॉन शुरू करने से पहले मैंने जांच की कि क्या एक ही नाम से एक निष्पादन पहले से चल रहा है। अगर यह होता है; तो एक नया शुरू मत करो।

इस तरह से मैं एक प्रक्रिया के उदाहरणों की संख्या को नियंत्रित करने में भी सक्षम था।

Answer 4

प्रक्रिया द्वारा बनाए गए मेमोरी ब्लॉक बनाने के लिए boost interprocess library का उपयोग करें। यदि यह पहले से मौजूद है, तो इसका मतलब है कि प्रक्रिया का एक और उदाहरण है। बाहर जाएं।

आपको जो चाहिए उससे अधिक सटीक लिंक this one होगा।

#include <boost/interprocess/shared_memory_object.hpp> 
#include <boost/scoped_ptr.hpp> 

int main() 
{ 
    using boost::interprocess; 
    boost::scoped_ptr<shared_memory_object> createSharedMemoryOrDie; 
    try 
    { 
    createSharedMemoryOrDie.reset( 
     new shared_memory_object(create_only, "shared_memory", read_write)); 
    } catch(...) 
    { 
    // executable is already running 
    return 1; 
    } 

    // do your thing here 
} 

Answer 5

मुझे लगता है कि इस योजना के काम करना चाहिए (और दुर्घटनाओं के खिलाफ भी मजबूत है):
पूर्वशर्त: आपके आवेदन के लिए एक पीआईडी ​​फ़ाइल (आमतौर पर/var/समय में /) नहीं है पीआईडी ​​फ़ाइल खोलने के लिए
1. कोशिश
2. यदि यह अस्तित्व में नहीं है, तो इसे बनाएं और इसे अपनी पीआईडी ​​लिखें। कार्यक्रम
3. के बाकी के साथ जारी रखें अगर यह मौजूद है, पीआईडी ​​
4. पढ़ पीआईडी ​​अभी भी चल रहा है और अपने कार्यक्रम का एक उदाहरण है, तो
5. बाहर निकलने पीआईडी ​​मौजूद नहीं है या किसी अन्य प्रोग्राम द्वारा उपयोग किया जाता है, पीआईडी ​​फ़ाइल को हटाएं और चरण 2 पर जाएं।
6. प्रोग्राम समाप्ति पर, पीआईडी ​​फ़ाइल को हटा दें।

चरण 5 में लूप सुनिश्चित करता है कि, यदि एक ही समय में दो उदाहरण शुरू हो गए हैं, तो अंत में केवल एक ही चल रहा है।

Answer 6

एक पिड फ़ाइल है और स्टार्टअप पर 'kill -0 <pid>' करें। फ़ाइल से मूल्य कहां पढ़ा जाता है। अगर प्रतिक्रिया है! = 0 तो डिमन जीवित नहीं है और आप इसे पुनरारंभ कर सकते हैं

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

Answer 7

मेरा मानना ​​है कि मेरे समाधान सरल है:

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

#include <sys/types.h> 
#include <unistd.h> 
#include <sstream> 

void main() 
{ 
    // get this process pid 
    pid_t pid = getpid(); 

    // compose a bash command that: 
    // check if another process with the same name as yours 
    // but with different pid is running 
    std::stringstream command; 
    command << "ps -eo pid,comm | grep <process name> | grep -v " << pid; 
    int isRuning = system(command.str().c_str()); 
    if (isRuning == 0) { 
     cout << "Another process already running. exiting." << endl; 
     return 1; 
    } 
    return 0; 
}