मैं किसी अन्य शेल में शुरू किए गए प्रोग्राम पर कैसे प्रतीक्षा करता हूं

Question

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

Comments

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

— स्लम

मुझे लगता है कि आप इन लाइनों के साथ-साथ ipcइंटरप्रोसेस संचार का उपयोग करके कुछ कर सकते हैं । man ipc।

— स्लम

हालाँकि आप इसे पुनः आरंभ करने के लिए कोई सेवा नहीं देख रहे हैं, इस प्रश्नोत्तर में वर्णित ईश्वर, मोनीत, या अन्य pkgs में से एक काम भी करेगा: unix.stackexchange.com/questions/75785/…

— slm

@ एसएलएम को किसी भी फाइल सिस्टम पर इस्तेमाल नहीं किया जा सकता है उदाहरण के लिए / proc / _pid_ / fd / 1 पर close_write पर प्रतीक्षा करें?

— hildred

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

— स्लम

Answer 1

मैं निश्चित रूप से EDIT # 3 समाधान (bellow देखें) पसंद करता हूं ।

अगर इसकी नहीं एक ही खोल में एक का उपयोग करते हुए शर्त के साथ पाश पर ps -p सच लौटने। प्रोसेसर के उपयोग को कम करने के लिए लूप में एक नींद रखो ।

while ps -p <pid> >/dev/null 2>&1
do
   sleep 10
done 

या अगर आपका UNIX समर्थन कर रहा है / खरीद रहा है (उदाहरण के लिए HP-UX अभी भी नहीं है)।

while [[ -d /proc/<pid> ]]
do 
    sleep 10
done

अगर आप टाइमआउट चाहते हैं

timeout=6  # timeout after 1mn  
while ((timeout > 0)) && ps -p <pid> >/dev/null 2>&1
do
   sleep 10
   ((timeout -= 1))
done 

EDIT # 1

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

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

EDIT # 2

अपने होम डायरेक्टरी में एक पाँटो बनाएँ:

$ mkfifo ~/tata

अपनी नौकरी के अंत में:

echo "it's done" > ~/tata

दूसरे काम की शुरुआत में (जो इंतजार कर रहा है):

cat ~/tata 

यह मतदान नहीं है यह पुराना अच्छा अवरोधक IO है।

EDIT # 3

संकेतों का उपयोग करना:

स्क्रिप्ट की शुरुआत में (जो) इंतज़ार कर रहे हैं:

echo $$ >>~/WeAreStopped
kill -STOP $$

आपकी लंबी नौकरी के अंत में:

if [[ -f ~/WeAreStopped ]] ; then
    xargs kill -CONT < ~/WeAreStopped
    rm ~/WeAreStopped
fi

Comments

मतदान, हाँ! लवली निर्णय: नींद को ट्यूनिंग के लिए प्रोसेसर समय या मेरा समय बर्बाद करें। बेहतर जवाब देना होगा।

— hildred

:) मतदान आपके लिए अच्छा है, मतदान स्टेटलेस है, मतदान विश्वसनीय है।

— इमैनुएल

मतदान धीमा है, पोलिंग प्रोसेसर समय बर्बाद करता है।

— hildred

0.01s के निष्पादन समय के साथ 4 घंटे के दौरान निष्पादित 1440 पीएस ने 14.4s का उपभोग किया होगा। नौकरी निर्भरता का प्रबंधन करने वाले एक अनुसूचक से बहुत कम: D

— Emmanuel

मुझे लगता है कि यह सबसे अच्छा विकल्प होने की संभावना है: stackoverflow.com/questions/1058047/… , भले ही यह hacky है।

— स्लम

Answer 2

आप कुछ ध्वज का उपयोग करने के लिए अपनी क्रोन नौकरी को संशोधित कर सकते हैं।

के बजाय

2  2 * * *           /path/my_binary

आप उपयोग कर सकते हैं

2  2 * * *           touch /tmp/i_m_running; /path/my_binary; rm /tmp/i_m_running

और इस फ़ाइल को स्क्रिप्ट या मैन्युअल रूप से भी मॉनिटर करें। यदि यह मौजूद है, तो आपका कार्यक्रम चल रहा है; अन्यथा जो आप चाहते हैं, करने के लिए स्वतंत्र महसूस करें।

स्क्रिप्ट नमूना:

while [[ -f /tmp/i_m_running ]] ; do
   sleep 10 ;
done
launch_whatever_you_want

यदि आप उपयोग करना पसंद नहीं करते हैं sleep, तो आप स्क्रिप्ट को संशोधित कर सकते हैं और इसे क्रोन के माध्यम से एक बार एक्स मिनट में चला सकते हैं।

उस स्थिति में स्क्रिप्ट का नमूना होगा:

[[ -f /tmp/i_m_running ]] && { echo "Too early" ; exit ; }
launch_whatever_you_want

यह तरीका थोड़ा आसान है, क्योंकि आपको अपनी क्रोन प्रक्रिया के पीआईडी ​​को खोजने की आवश्यकता नहीं है।

Answer 3

एक प्रक्रिया के लिए किसी अन्य प्रक्रिया के समाप्त होने की प्रतीक्षा करने की कोई सुविधा नहीं है, एक माता-पिता को छोड़कर अपनी एक बच्चे की प्रक्रिया को समाप्त करने के लिए प्रतीक्षा करने के लिए। यदि आप कर सकते हैं, तो स्क्रिप्ट के माध्यम से प्रोग्राम लॉन्च करें:

do_large_amount_of_work
start_interactive_program

यदि आप ऐसा नहीं कर सकते हैं, उदाहरण के लिए, इससे पहले कि आप एक क्रॉन जॉब से बड़ी मात्रा में काम शुरू करना चाहते हैं, लेकिन आपके सत्र के संदर्भ से इंटरएक्टिव प्रोग्राम, तो इसे बनाएं

do_large_amount_of_work
notify_completion

लागू करने के कई तरीके हैं notify_completion। कुछ डेस्कटॉप वातावरण एक सूचना तंत्र प्रदान करते हैं ( एक दूरस्थ एक्स डिस्प्ले पर एक विंडो खोलें (क्यों "ओपन डिस्प्ले नहीं कर सकता"); उपयोगी हो सकता है)। आप फ़ाइल परिवर्तन सूचनाओं का उपयोग करके भी एक बना सकते हैं। लिनक्स पर, फाइल चेंज नोटिफिकेशन फैसिलिटी इनोटिफाई है ।

do_large_amount_of_work
echo $? >/path/to/finished.stamp

के निर्माण पर प्रतिक्रिया करने के लिए /path/to/finished.stamp:

inotifywait -e close_write -q /path/to/finished.stamp
start_interactive_program

यदि आप तरीका बदल नहीं सकते हैं do_large_amount_of_work, लेकिन आपको पता है कि यह किस फ़ाइल को अंतिम रूप देता है, तो आप उस फ़ाइल के बंद होने पर प्रतिक्रिया करने के लिए उसी तंत्र का उपयोग कर सकते हैं। आप अन्य घटनाओं पर भी प्रतिक्रिया कर सकते हैं जैसे फ़ाइल का नाम बदलना ( inotifywaitसंभावनाओं की सूची के लिए मैनुअल देखें )।

Answer 4

क्या स्क्रिप्ट को क्रोनजॉब द्वारा ट्रिगर किया जा रहा है, एक खाली शेल स्क्रिप्ट लाएँ जिसमें आप ज़रूरत पड़ने पर अनुवर्ती कार्य सम्मिलित कर सकें।

यह गिल्स के दृष्टिकोण के समान है।

cronjob-task.sh शामिल हैं:

# do_large_amount_of_work

./post-execute.sh

जहां post-execute.shआमतौर पर खाली होता है, जब तक आप यह नहीं देखते हैं कि आपको एक अनुवर्ती कार्य को ट्रिगर करने की आवश्यकता है।