जैसा कि आप शायद बता सकते हैं कि ऐसा करने के बहुत सारे तरीके हैं।
अपने "UPDATE # 2" के बारे में - आम तौर पर बोलना, माता-पिता के बच्चे के पदानुक्रम में किसी भी प्रक्रिया को समाप्त करना आम तौर पर सभी संबंधित प्रक्रियाओं को समाप्त कर देगा। लेकिन इसके कई अपवाद भी हैं। आदर्श रूप से, आप एक प्रक्रिया के पेड़ में अंतिम 'बच्चे' को समाप्त करना चाहते हैं, फिर इस बच्चे के माता-पिता को बाहर निकलना चाहिए अगर उनके पास चलाने के लिए कोई अन्य कार्य नहीं है। लेकिन अगर आप किसी माता-पिता को मारते हैं, तो संकेत को बच्चों को छोड़ दिया जाना चाहिए जब माता-पिता की मृत्यु हो जाती है और बच्चों को भी बाहर निकलना चाहिए - लेकिन ऐसे मामले हैं जहां बच्चे प्रक्रिया संकेत (जाल या इसी तरह के तंत्र के माध्यम से) को अनदेखा कर सकते हैं और जारी रख सकते हैं चलाने के लिए एक 'इनिट' प्रक्रिया (या इसी तरह) द्वारा विरासत में मिला होगा। लेकिन प्रक्रिया व्यवहार का यह विषय जटिल हो सकता है और मैं इसे वहां छोड़ दूँगा ...
एक विधि मुझे पसंद है अगर मैं एक नियंत्रण स्क्रिप्ट का उपयोग नहीं करना चाहता (अगला वर्णित है) प्रक्रिया शुरू करने और प्रबंधित करने के लिए 'स्क्रीन' उपयोगिता का उपयोग करना है। 'स्क्रीन' कमांड सुविधाओं से भरपूर है और इसमें कुछ समय लग सकता है। मैं आपको पूर्ण विवरण के लिए 'स्क्रीन' मैन पेज पढ़ने के लिए प्रोत्साहित करता हूँ। पृष्ठभूमि में एक प्रक्रिया शुरू करने के लिए एक त्वरित उदाहरण कमांड होगा:
स्क्रीन -d -m / path / to / program
यह 'स्क्रीन' सत्र के अंदर "/ पथ / टू / प्रोग्राम" शुरू करेगा।
आप कमांड के साथ अपना रनिंग सेशन देख सकते हैं:
स्क्रीन-हील्स
और किसी भी समय आप कमांड के साथ अपने रनिंग प्रोग्राम को फिर से कनेक्ट कर सकते हैं:
स्क्रीन -r
और फिर इसे ^ C या जो भी हो, समाप्त करें।
अपनी प्रक्रिया में अपनी प्रक्रिया से पुन: कनेक्ट और डिस्कनेक्ट करने में सक्षम होने के अलावा, यह है कि 'स्क्रीन' किसी भी स्टडआउट () को कैप्चर करेगा जो आपके प्रोग्राम का उत्पादन कर सकता है।
लेकिन इन मामलों में मेरी व्यक्तिगत प्राथमिकता एक नियंत्रण कार्यक्रम है जो एक प्रक्रिया की शुरुआत और ठहराव का प्रबंधन करता है। यह कुछ हद तक जटिल हो सकता है और कुछ यकीनन जटिल स्क्रिप्टिंग की आवश्यकता होती है। और किसी भी स्क्रिप्ट की तरह, इसे करने के दर्जनों अच्छे तरीके हैं। मैंने एप्लिकेशन को प्रारंभ करने और रोकने के लिए नियमित रूप से उपयोग की जाने वाली विधि का एक बैश उदाहरण शामिल किया है। यदि आपका कार्य सरल है, तो आप इसे सीधे नियंत्रण स्क्रिप्ट में सम्मिलित कर सकते हैं - या आपके पास यह नियंत्रण स्क्रिप्ट किसी अन्य बाहरी प्रोग्राम को कॉल कर सकती है। ध्यान दें कि यह उदाहरण प्रक्रिया के प्रबंधन के संदर्भ में व्यापक नहीं है। मैंने इस तरह के परिदृश्यों की संभावना को छोड़ दिया है: यह सुनिश्चित करना कि जब आप "स्टार्ट" विकल्प का उपयोग करते हैं तो स्क्रिप्ट पहले से ही नहीं चल रही है, यह पुष्टि करते हुए कि चल रही पीआईडी वास्तव में आपके द्वारा शुरू की गई प्रक्रिया है (जैसे आपकी स्क्रिप्ट hasn ' t की मृत्यु हो गई और उसी PID का उपयोग करके एक और प्रक्रिया शुरू की गई), और यह पुष्टि करते हुए कि स्क्रिप्ट वास्तव में पहले 'मार' अनुरोध पर प्रतिक्रिया (बाहर) हुई। इन सभी जांचों को करना जटिल हो सकता है और मैं उदाहरण को बहुत लंबा और जटिल नहीं बनाना चाहता। आप अपने शेल स्क्रिप्टिंग का अभ्यास करने के लिए उदाहरण को संशोधित करना चाह सकते हैं।
निम्नलिखित प्रोग्राम को "प्रोग्रामक्टल" नामक फ़ाइल में सहेजें, इसे कमांड के साथ निष्पादन योग्य बनाएं:
chmod 755 प्रोग्रामैक्टल
फिर फ़ाइल को संपादित करें और "myscript" से शुरू होने वाले केस-सेक्शन में अपना कोड / स्क्रिप्ट जोड़ें।
एक बार सब कुछ जगह में होने के बाद, "प्रोग्रामक्टल" वर्तमान निर्देशिका में है, तो आप अपने कार्यक्रम को इसके साथ शुरू कर सकते हैं:
./programctl प्रारंभ
और इसके साथ बंद करो:
./programctl स्टॉप
चीयर्स।
#!/bin/bash
# Description: A wrapper script used to stop/start another script.
#--------------------------------------
# Define Global Environment Settings:
#--------------------------------------
# Name and location of a persistent PID file
PIDFILE="/tmp/tmpfile-$LOGNAME.txt"
#--------------------------------------
# Check command line option and run...
# Note that "myscript" should not
# provided by the user.
#--------------------------------------
case $1
in
myscript)
# This is where your script would go.
# If this is a routine 'bash' shell script, you can enter
# the script below as illustrated in the example.
# Or you could simply provide the path and parameters
# to another script such as /dir/name/command -options
# Example of an embedded script:
while true
do
# do something over and over...
sleep 1
done
# Example of an external script:
/usr/local/bin/longrun -x
;;
start)
# Start your script in the background.
# (Note that this is a recursive call to the wrapper
# itself that effectively runs your script located above.)
$0 myscript &
# Save the backgound job process number into a file.
jobs -p > $PIDFILE
# Disconnect the job from this shell.
# (Note that 'disown' command is only in the 'bash' shell.)
disown %1
# Print a message indicating the script has been started
echo "Script has been started..."
;;
stop)
# Read the process number into the variable called PID
read PID < $PIDFILE
# Remove the PIDFILE
rm -f $PIDFILE
# Send a 'terminate' signal to process
kill $PID
# Print a message indicating the script has been stopped
echo "Script has been stopped..."
;;
*)
# Print a "usage" message in case no arguments are supplied
echo "Usage: $0 start | stop"
;;
esac
