बैश: अनंत नींद (अनंत अवरुद्ध)

Question

मैं startxएक्स को शुरू करने के लिए उपयोग करता हूं जो मेरा मूल्यांकन करेगा .xinitrc। मेरे में .xinitrcमैं का उपयोग कर मेरी विंडो प्रबंधक शुरू /usr/bin/mywm। अब, अगर मैं अपने WM को मारता हूं (कुछ अन्य WM टेस्ट करने के लिए), तो X भी समाप्त हो जाएगा क्योंकि .xinitrcस्क्रिप्ट EOF तक पहुंच गई थी। इसलिए मैंने इसे अपने अंत में जोड़ा .xinitrc:

while true; do sleep 10000; done

अगर मैं अपने WM को मारता हूं तो इस तरह एक्स समाप्त नहीं होगा। अब मेरा सवाल है: मैं सोने की जगह नींद कैसे ले सकता हूं ? क्या कोई कमांड है जो लिपि को फ्रीज करने जैसा होगा?

सादर

Answer 1

sleep infinity बिल्ली के साथ दुर्व्यवहार के बिना यह वास्तव में सुझाव देता है और काम करता है।

Comments

ठंडा। दुर्भाग्य से मेरा बिजीबॉक्स समझ में नहीं आता है।

— उपयोगकर्ता

बीएसडी (या कम से कम ओएस एक्स) sleep infinityया तो समझ में नहीं आता है , हालांकि लिनक्स के बारे में जानने के लिए यह एक अच्छी बात थी। हालांकि, while true; do sleep 86400; doneएक पर्याप्त विकल्प होना चाहिए।

— इवान एक्स

इसके बारे में, मैंने कुछ शोध किए जिन्हें मैंने एक अलग उत्तर में प्रलेखित किया। संक्षेप में: infinityC को "string" से a में परिवर्तित किया जाता है double। फिर doubleअनुमति दी गई अधिकतम मूल्यों को काट दिया जाता है timespec, जिसका अर्थ है बहुत बड़ी मात्रा में सेकंड (वास्तुकला-निर्भर) लेकिन, सिद्धांत रूप में, परिमित।

— jp48

Answer 2

tail ब्लॉक नहीं करता है

हमेशा की तरह: हर चीज के लिए एक उत्तर होता है, जो छोटा, समझने में आसान, अनुसरण करने में आसान और पूरी तरह से गलत होता है। यहाँ tail -f /dev/nullइस श्रेणी में आता है;)

यदि आप इसे देखते हैं तो आप strace tail -f /dev/nullदेखेंगे कि यह समाधान अवरुद्ध होने से दूर है! यह शायद sleepप्रश्न में समाधान से भी बदतर है , क्योंकि यह inotifyसिस्टम जैसे अनमोल संसाधनों का उपयोग करता है। इसके अलावा अन्य प्रक्रियाएं जो लूप /dev/nullबनाने के लिए लिखती हैं tail। (मेरे Ubuntu64 16.10 पर यह पहले से ही व्यस्त प्रणाली पर प्रति सेकंड कई 10 syscalls जोड़ता है।)

सवाल ब्लॉकिंग कमांड के लिए था

दुर्भाग्य से, ऐसी कोई बात नहीं है ..

पढ़ें: मुझे यह नहीं पता है कि इसे सीधे शेल के साथ संग्रहीत करें।

सब कुछ (यहां तक ​​कि sleep infinity) कुछ संकेत द्वारा बाधित हो सकता है। इसलिए यदि आप वास्तव में सुनिश्चित होना चाहते हैं तो यह असाधारण रूप से वापस नहीं आता है, यह एक लूप में चलना चाहिए, जैसे कि आपने पहले ही अपने लिए किया था sleep। कृपया ध्यान दें, (लिनक्स पर) /bin/sleepजाहिरा तौर पर 24 दिनों में छाया हुआ है (एक नज़र डालें strace sleep infinity), इसलिए आप जो सबसे अच्छा कर सकते हैं वह यह है:

while :; do sleep 2073600; done

(ध्यान दें कि मेरा मानना ​​है कि sleep24 दिनों की तुलना में उच्च मूल्यों के लिए आंतरिक रूप से लूप होता है, लेकिन इसका मतलब है: यह अवरुद्ध नहीं है, यह धीरे-धीरे लूपिंग है। इसलिए इस लूप को बाहर क्यों नहीं ले जाएं?)

.. लेकिन आप एक अनाम के साथ काफी निकट आ सकते हैं fifo

आप कुछ बना सकते हैं जो वास्तव में तब तक ब्लॉक करता है जब तक कि कोई संकेत नहीं है प्रक्रिया को भेजें। निम्नलिखित उपयोग bash 4, 2 पीआईडी ​​और 1 fifo:

bash -c 'coproc { exec >&-; read; }; eval exec "${COPROC[0]}<&-"; wait'

आप जाँच सकते हैं कि यह वास्तव में ब्लॉक के साथ straceयदि आप चाहें:

strace -ff bash -c '..see above..'

इसका निर्माण कैसे हुआ

readयदि कोई इनपुट डेटा नहीं है तो ब्लॉक करें (कुछ अन्य उत्तर देखें)। हालांकि, tty(उर्फ stdin) आमतौर पर एक अच्छा स्रोत नहीं है, क्योंकि जब उपयोगकर्ता लॉग आउट करता है तो यह बंद हो जाता है। इसके अलावा यह कुछ इनपुट चोरी कर सकता है tty। अच्छा नहीं है।

readब्लॉक करने के लिए , हमें कुछ ऐसी चीज की प्रतीक्षा करने की आवश्यकता है fifoजो कभी भी वापस नहीं आएगी। में bash 4एक कमांड जो वास्तव में इस तरह के एक के साथ हमें प्रदान कर सकते है fifo: coproc। यदि हम ब्लॉकिंग का इंतजार करते हैं read(जो कि हमारा है coproc), तो हम कर रहे हैं। अफसोस की बात यह है कि खुले दो पीआईडी ​​और ए रखने की जरूरत है fifo।

एक नाम के साथ वेरिएंट fifo

यदि आप एक नाम का उपयोग करके परेशान नहीं करते हैं fifo, तो आप इस प्रकार कर सकते हैं:

mkfifo "$HOME/.pause.fifo" 2>/dev/null; read <"$HOME/.pause.fifo"

पढ़ने पर लूप का उपयोग नहीं करना थोड़ा टेढ़ा है, लेकिन आप इसे fifoजितनी बार चाहें उपयोग कर सकते हैं और readएस टर्मैट का उपयोग कर सकते हैं touch "$HOME/.pause.fifo"(यदि एक से अधिक बार प्रतीक्षा की जा रही है, तो सभी एक ही बार में समाप्त हो जाते हैं)।

या लिनक्स pause()syscall का उपयोग करें

अनंत अवरोधन के लिए, एक लिनक्स कर्नेल कॉल है, जिसे कहा जाता है pause(), जो हम चाहते हैं: हमेशा के लिए प्रतीक्षा करें (जब तक कोई संकेत नहीं आता)। हालाँकि इस (अभी तक) के लिए कोई उपयोगकर्ता कार्यक्रम नहीं है।

सी

ऐसा प्रोग्राम बनाना आसान है। यहां एक बहुत छोटा लिनक्स प्रोग्राम बनाने के लिए एक स्निपेट है जिसे pauseअनिश्चित काल के लिए रोक दिया जाता है (आवश्यकताएं diet, gccआदि):

printf '#include <unistd.h>\nint main(){for(;;)pause();}' > pause.c;
diet -Os cc pause.c -o pause;
strip -s pause;
ls -al pause

python

यदि आप स्वयं कुछ संकलन नहीं करना चाहते हैं, लेकिन आपने pythonइंस्टॉल कर लिया है, तो आप लिनक्स के तहत इसका उपयोग कर सकते हैं:

python -c 'while 1: import ctypes; ctypes.CDLL(None).pause()'

(नोट: exec python -c ...वर्तमान शेल को बदलने के लिए उपयोग करें , यह एक पीआईडी ​​को मुक्त करता है। समाधान को कुछ आईओ पुनर्निर्देशन के साथ ही अप्रयुक्त एफडी से मुक्त किया जा सकता है। यह आपके ऊपर है।)

यह कैसे काम करता है (मुझे लगता है): ctypes.CDLL(None)मानक सी लाइब्रेरी को लोड करता है और pause()कुछ अतिरिक्त लूप के भीतर इसमें फ़ंक्शन चलाता है । सी संस्करण की तुलना में कम कुशल, लेकिन काम करता है।

आपके लिए मेरी सिफारिश:

लूपिंग स्लीप पर रहें। यह समझना बहुत आसान है, बहुत पोर्टेबल है, और अधिकांश समय ब्लॉक करता है।

Comments

@ और आम तौर पर आपको इसकी आवश्यकता नहीं होती है trap(जो शेल के संकेतों के व्यवहार को संशोधित करता है) और न ही पृष्ठभूमि (जो शेल को टर्मिनल से स्ट्रैग + सी की तरह सिग्नल को बाधित करने की अनुमति देता है)। इतना sleep infinityपर्याप्त है (व्यवहार करता है जैसे exec sleep infinityकि यह अंतिम कथन है। अंतर का उपयोग करने के लिए देखें strace -ffDI4 bash -c 'YOURCODEHERE')। लूपिंग नींद बेहतर है, क्योंकि sleepकुछ निश्चित परिस्थितियों में वापस आ सकती है। उदाहरण के लिए, आप नहीं चाहते हैं कि X11 अचानक a पर बंद हो जाए killall sleep, सिर्फ इसलिए कि नींद की जगह लूप .xstartupखत्म हो जाए sleep infinity।

— तिनो

थोड़ा अस्पष्ट हो सकता है, लेकिन s6-pauseउपयोगकर्ता को चलाने के लिए एक कमांड है pause(), वैकल्पिक रूप से विभिन्न संकेतों को अनदेखा करना।

— पैट्रिक

/bin/sleepजैसा कि आप कहते हैं कि @Tino 24 दिनों में छाया हुआ नहीं है। आप इसे अपडेट कर सकते हैं तो अच्छा होगा। अभी लिनक्स पर, यह कोड सक्रिय है। यह nanosleep()24 दिनों के लिए व्यक्तिगत syscalls कैप करता है , लेकिन उन्हें एक लूप में कहता है। इसलिए sleep infinity24 दिनों के बाद बाहर नहीं निकलना चाहिए। doubleसकारात्मक अनंत एक में परिवर्तित हो जाता struct timespec। rpl_nanosleepGDB में देखते हुए , Ubuntu 16.04 में infinityपरिवर्तित हो जाता है { tv_sec = 9223372036854775807, tv_nsec = 999999999 }।

— nh2

@ nh2 यह पहले से ही पाठ में उल्लेख किया गया था कि नींद शायद पूरी तरह से अवरुद्ध होने के बजाय लूप करती है। मैंने इसे अब थोड़ा संपादित किया है उम्मीद है कि इस तथ्य को थोड़ा और स्पष्ट कर देगा। कृपया इस " शायद " पर ध्यान दें , क्योंकि straceअकेले से मैं इस तथ्य को साबित नहीं कर सकता कि वास्तव में कुछ लूपिंग कोड संकलित है sleep, और मैं इसे (या डिकंपाइल /bin/sleep) परीक्षण करने के लिए सिर्फ 24 दिन इंतजार नहीं करना चाहता । यह हमेशा रक्षात्मक रूप से प्रोग्राम करने के लिए बेहतर है, अगर कोई कठिन गणितीय प्रमाण नहीं है, कि वास्तव में कुछ ऐसा है, जैसा कि ऐसा लगता है। इसके अलावा कभी भी किसी चीज पर भरोसा न करें:killall -9 sleep

— टीनो

ठहराव () विकल्प को पर्ल के साथ बहुत आसानी से किया जा सकता है: perl -MPOSIX -e 'pause ()'

— tgoodhart

Answer 3

शायद यह बदसूरत लगता है, लेकिन क्यों न केवल catइसे चलाएं और इसे हमेशा के लिए इनपुट की प्रतीक्षा करें?

Comments

यह काम नहीं करता है यदि आपके पास एक लटका हुआ पाइप नहीं है जिसमें से पढ़ना है। कृपया सलाह दें।

— मैट जॉइनर

@ मट, शायद एक पाइप और catइसे बनाते हैं ? mkfifo pipe && cat pipe

— मिशैल ट्रायबस

@Twalberg क्या कहती है, लेकिन इसके अलावा आप तुरंत 3 को पुनः असाइन कर सकते हैं और इसे अनलिंक कर सकते हैं, जैसा कि यहाँ दिखाया गया है: superuser.com/a/633185/762481

— jp48

Answer 4

टीएल; डीआर: sleep infinityवास्तव में अनुमत अधिकतम समय सोता है, जो परिमित है।

आश्चर्य है कि इसे कहीं भी प्रलेखित नहीं किया गया है, मैंने जीएनयू कोर्यूटिल्स से स्रोतों को पढ़ने के लिए परेशान किया और मैंने पाया कि यह मोटे तौर पर निष्पादित करता है:

1. strtodConvert अनंत ’को दोहरी परिशुद्धता में बदलने के लिए पहले तर्क पर सी stdlib से उपयोग करें । तो, IEEE 754 डबल सटीक मान 64-बिट पॉजिटिव इनफिनिटी वैल्यू को secondsवेरिएबल में स्टोर किया जाता है।
2. आह्वान xnanosleep(seconds)( gnulib में पाया गया ), यह बदले में invokes dtotimespec(seconds)( भी gnulib में ) से परिवर्तित करने के doubleलिए struct timespec।
3. struct timespecकेवल संख्याओं की एक जोड़ी है: पूर्णांक भाग (सेकंड में) और आंशिक भाग (नैनोसेकंड में)। सकारात्मक रूप से पूर्णांक में सकारात्मक अनंत को परिवर्तित करने के परिणामस्वरूप अपरिभाषित व्यवहार (सी मानक से .36.3.1.4 देखें) होगा, इसलिए इसके बजाय यह कम हो जाता है TYPE_MAXIMUM (time_t)।
4. का वास्तविक मान TYPE_MAXIMUM (time_t)मानक में सेट नहीं है (यहां तक sizeof(time_t)कि नहीं है); इसलिए, उदाहरण के लिए आइए x86-64 को हाल ही के लिनक्स कर्नेल से चुनें।

यह TIME_T_MAXलिनक्स कर्नेल में है, जिसे परिभाषित किया गया है ( time.h):

(time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)

ध्यान दें कि time_tहै __kernel_time_tऔर time_tहै long; LP64 डेटा मॉडल का उपयोग किया जाता है, इसलिए sizeof(long)8 (64 बिट्स) है।

जिसमें परिणाम: TIME_T_MAX = 9223372036854775807।

वह है: sleep infinite9223372036854775807 सेकंड (10 ^ 11 वर्ष) की वास्तविक नींद के समय में परिणाम। और 32-बिट लिनक्स सिस्टम ( sizeof(long)4 है (32 बिट्स)) के लिए: 2147483647 सेकंड (68 वर्ष; वर्ष 2038 समस्या भी देखें )।

---

संपादित करें : जाहिरा तौर पर nanosecondsकहा जाने वाला फ़ंक्शन सीधे syscall नहीं है, लेकिन एक ओएस पर निर्भर आवरण ( gnulib में भी परिभाषित )।

वहाँ एक परिणाम के रूप में एक अतिरिक्त कदम है: कुछ सिस्टम जहां के लिए HAVE_BUG_BIG_NANOSLEEPहै trueनींद 24 दिनों तक छोटा कर दिया जाता है और फिर एक पाश में कहा जाता है। यह कुछ (या सभी?) लिनक्स डिस्ट्रो के लिए मामला है। ध्यान दें कि इस रैपर का उपयोग नहीं किया जा सकता है यदि कॉन्फ़िगर- टाइम परीक्षण सफल होता है ( स्रोत )।

विशेष रूप से, यह होगा 24 * 24 * 60 * 60 = 2073600 seconds(प्लस 999999999 नैनोसेकंड); लेकिन यह निर्दिष्ट कुल नींद के समय का सम्मान करने के लिए एक लूप में कहा जाता है। इसलिए पिछले निष्कर्ष वैध बने हुए हैं।

---

अंत में, परिणामस्वरूप नींद का समय अनंत नहीं है, बल्कि सभी व्यावहारिक उद्देश्यों के लिए पर्याप्त है , भले ही परिणामी वास्तविक समय चूक पोर्टेबल न हो; यह OS और आर्किटेक्चर पर निर्भर करता है।

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

Comments

अगले कोरयूटिल्स में, sleep infinityअब वास्तव में हमेशा के लिए बिना लूप के सो जाएगा: lists.gnu.org/archive/html/bug-gnulib/2020-02/msg00081.html

— व्लादिमीर

Answer 5

sleep infinityसबसे सुरुचिपूर्ण दिखता है, लेकिन कभी-कभी यह किसी कारण से काम नहीं करता है। उस मामले में, आप अन्य अवरुद्ध आदेशों जैसे कोशिश कर सकते हैं cat, read, tail -f /dev/null, grep aआदि

Comments

tail -f /dev/nullएक सास मंच पर मेरे लिए एक काम कर समाधान भी था

— schmunk

tail -f /dev/nullस्टड का सेवन नहीं करने का भी फायदा है। मैंने इसका उपयोग उस कारण से किया है।

— सुदो बैश

इस विकल्प पर विचार करने वालों को इस विकल्प के प्रभाव के बारे में जानने के लिए इस उत्तर को पढ़ना चाहिए ।

— शैडो

Answer 6

अपने आप में एक SIGSTOP भेजने के बारे में क्या ?

SIGCONT प्राप्त होने तक इस प्रक्रिया को रोकना चाहिए। जो आपके मामले में है: कभी नहीं।

kill -STOP "$$";
# grace time for signal delivery
sleep 60;

Comments

सिग्नल एसिंक्रोनस हैं। तो निम्न हो सकता है: ए) शेल कॉल किल बी) किल कर्नेल को बताता है कि शेल को सिग्नल मिलेगा STOP c) किल टर्मेट्स और रिटर्न टू शेल d) शेल जारी है (हो सकता है कि स्क्रिप्ट समाप्त हो जाए क्योंकि ई) कर्नेल आखिरकार वितरित करने का समय पाता है। संकेत बंद करने के लिए खोल

— नहीं-उपयोगकर्ता

@ महान सूचना, संकेतों की अतुल्यकालिक प्रकृति के बारे में नहीं सोचा था। धन्यवाद!

— मच्यूलेनिक

Answer 7

मुझे समझाएं कि क्यों sleep infinityकाम करता है हालांकि यह प्रलेखित नहीं है। jp48 का उत्तर भी उपयोगी है।

सबसे महत्वपूर्ण बात: निर्दिष्ट infया infinity(दोनों मामले-असंवेदनशील) करके, आप सबसे लंबे समय तक सो सकते हैं जब आपका कार्यान्वयन अनुमति देता है (यानी के छोटे मूल्य HUGE_VALऔर TYPE_MAXIMUM(time_t))।

अब विवरण में खुदाई करते हैं। sleepआदेश के स्रोत कोड को कोरुटिल्स / src / sleep.c से पढ़ा जा सकता है । अनिवार्य रूप से, फ़ंक्शन ऐसा करता है:

double s; //seconds
xstrtod (argv[i], &p, &s, cl_strtod); //`p` is not essential (just used for error check).
xnanosleep (s);

समझ xstrtod (argv[i], &p, &s, cl_strtod)

xstrtod()

Gnulib / lib / xstrtod.c के अनुसार , xstrtod()धर्मान्तरित स्ट्रिंग argv[i]का कॉल एक फ्लोटिंग पॉइंट वैल्यू के लिए होता है और इसे *sएक परिवर्तित फ़ंक्शन का उपयोग करके स्टोर करता है cl_strtod()।

cl_strtod()

जैसा कि coreutils / lib / cl-strtod.c से देखा जा सकता है , cl_strtod()एक स्ट्रिंग को फ्लोटिंग पॉइंट वैल्यू में परिवर्तित करता है, का उपयोग करके strtod()।

strtod()

के अनुसार man 3 strtod, strtod()एक स्ट्रिंग को प्रकार के मान में परिवर्तित करता है double। मेनपेज कहता है

(स्ट्रिंग का प्रारंभिक भाग) का अपेक्षित रूप है ... या (iii) एक अनन्तता, या ...

और एक अनंत के रूप में परिभाषित किया गया है

एक अनन्तता या तो "INF" या "INFINITY" है, मामले की अवहेलना।

हालांकि दस्तावेज़ बताता है

यदि सही मान अतिप्रवाह होगा, तो प्लस या माइनस HUGE_VAL( HUGE_VALF, HUGE_VALL) वापस आ जाएगा

, यह स्पष्ट नहीं है कि एक अनन्तता का इलाज कैसे किया जाता है। तो चलिए सोर्स कोड gnulib / lib / strtod.c देखते हैं । हम जो पढ़ना चाहते हैं, वह है

else if (c_tolower (*s) == 'i'
         && c_tolower (s[1]) == 'n'
         && c_tolower (s[2]) == 'f')
  {
    s += 3;
    if (c_tolower (*s) == 'i'
        && c_tolower (s[1]) == 'n'
        && c_tolower (s[2]) == 'i'
        && c_tolower (s[3]) == 't'
        && c_tolower (s[4]) == 'y')
      s += 5;
    num = HUGE_VAL;
    errno = saved_errno;
  }

इस प्रकार, INFऔर INFINITY(दोनों मामले असंवेदनशील) के रूप में माना जाता है HUGE_VAL।

HUGE_VAL परिवार

चलो N1570 को C मानक के रूप में उपयोग करते हैं । HUGE_VAL, HUGE_VALFऔर HUGE_VALLमैक्रोज़ को .127.12-3 में परिभाषित किया गया है

मैक्रो
    HUGE_VAL
एक सकारात्मक डबल निरंतर अभिव्यक्ति का विस्तार करता है, जरूरी नहीं कि फ्लोट के रूप में प्रतिनिधित्व योग्य हो। मैक्रोज़
    HUGE_VALF
    HUGE_VALL
क्रमशः फ्लोट और लंबे डबल एनालॉग हैं HUGE_VAL।

HUGE_VAL, HUGE_VALFऔर HUGE_VALLएक कार्यान्वयन में सकारात्मक infinities हो सकता है जो infinities का समर्थन करता है।

और §7.12.1-5 में

एक अस्थायी परिणाम overflows और डिफ़ॉल्ट राउंडिंग प्रभाव में है, तो समारोह मैक्रो का मान देता है HUGE_VAL, HUGE_VALFया HUGE_VALLवापसी प्रकार के अनुसार

समझ xnanosleep (s)

अब हम सभी के सार को समझते हैं xstrtod()। उपरोक्त स्पष्टीकरण से, यह स्पष्ट है कि xnanosleep(s)हमने पहले वास्तव में इसका मतलब देखा है xnanosleep(HUGE_VALL)।

xnanosleep()

स्रोत कोड gnulib / lib / xnanosleep.c के अनुसार , xnanosleep(s)अनिवार्य रूप से यह करता है:

struct timespec ts_sleep = dtotimespec (s);
nanosleep (&ts_sleep, NULL);

dtotimespec()

यह फ़ंक्शन प्रकार के तर्क को doubleऑब्जेक्ट के प्रकार में कनवर्ट करता है struct timespec। चूंकि यह बहुत सरल है, मुझे स्रोत कोड gnulib / lib / dtotimespec.c का हवाला देते हैं । सभी टिप्पणियाँ मेरे द्वारा जोड़ी गई हैं।

struct timespec
dtotimespec (double sec)
{
  if (! (TYPE_MINIMUM (time_t) < sec)) //underflow case
    return make_timespec (TYPE_MINIMUM (time_t), 0);
  else if (! (sec < 1.0 + TYPE_MAXIMUM (time_t))) //overflow case
    return make_timespec (TYPE_MAXIMUM (time_t), TIMESPEC_HZ - 1);
  else //normal case (looks complex but does nothing technical)
    {
      time_t s = sec;
      double frac = TIMESPEC_HZ * (sec - s);
      long ns = frac;
      ns += ns < frac;
      s += ns / TIMESPEC_HZ;
      ns %= TIMESPEC_HZ;

      if (ns < 0)
        {
          s--;
          ns += TIMESPEC_HZ;
        }

      return make_timespec (s, ns);
    }
}

चूंकि time_tएक अभिन्न प्रकार के रूप में परिभाषित किया गया है (देखें 77.27.1-3), यह स्वाभाविक है कि हम मानते हैं कि प्रकार time_tका अधिकतम मूल्य HUGE_VAL(प्रकार का double) से छोटा है , जिसका अर्थ है कि हम अतिप्रवाह मामले में प्रवेश करते हैं। (वास्तव में इस धारणा की आवश्यकता नहीं है, सभी मामलों में, प्रक्रिया अनिवार्य रूप से समान है।)

make_timespec()

जिस आखिरी दीवार पर हमें चढ़ना है, वह है make_timespec()। बहुत सौभाग्य से, यह इतना सरल है कि स्रोत कोड gnulib / lib / timespec.h का हवाला देना काफी है।

_GL_TIMESPEC_INLINE struct timespec
make_timespec (time_t s, long int ns)
{
  struct timespec r;
  r.tv_sec = s;
  r.tv_nsec = ns;
  return r;
}

Answer 8

मुझे हाल ही में ऐसा करने की आवश्यकता थी। मैं निम्नलिखित समारोह के साथ आया था जो किसी भी बाहरी कार्यक्रम को बुलाए बिना हमेशा के लिए सोने की अनुमति देगा:

snore()
{
    local IFS
    [[ -n "${_snore_fd:-}" ]] || { exec {_snore_fd}<> <(:); } 2>/dev/null ||
    {
        # workaround for MacOS and similar systems
        local fifo
        fifo=$(mktemp -u)
        mkfifo -m 700 "$fifo"
        exec {_snore_fd}<>"$fifo"
        rm "$fifo"
    }
    read ${1:+-t "$1"} -u $_snore_fd || :
}

नोट: मैंने पहले इस का एक संस्करण पोस्ट किया था जो हर बार फ़ाइल डिस्क्रिप्टर को खोलना और बंद कर देगा, लेकिन मैंने पाया कि कुछ सिस्टम पर ऐसा करने से सैकड़ों बार एक सेकंड में अंततः लॉक हो जाएगा। इस प्रकार नया समाधान कॉल के बीच फाइल डिस्क्रिप्टर को फंक्शन में रखता है। बैश वैसे भी बाहर निकलने पर साफ कर देगा।

इसे बस / बिन / नींद की तरह कहा जा सकता है, और यह अनुरोधित समय के लिए सो जाएगा। मापदंडों के बिना कहा जाता है, यह हमेशा के लिए लटका रहेगा।

snore 0.1  # sleeps for 0.1 seconds
snore 10   # sleeps for 10 seconds
snore      # sleeps forever

यहाँ मेरे ब्लॉग पर अत्यधिक विवरण के साथ एक राइटअप है

Answer 9

यह दृष्टिकोण प्रक्रिया को जीवित रखने के लिए किसी भी संसाधन का उपभोग नहीं करेगा।

while :; do sleep 1; done & kill -STOP $! && wait $!

टूट - फूट

• while :; do sleep 1; done & पृष्ठभूमि में एक डमी प्रक्रिया बनाता है
• kill -STOP $! बैकग्राउंड प्रोसेस को रोक देता है
• wait $! पृष्ठभूमि प्रक्रिया की प्रतीक्षा करें, यह हमेशा के लिए अवरुद्ध हो जाएगा, क्योंकि पृष्ठभूमि प्रक्रिया को पहले रोका गया था

Answer 10

विंडो मैनेजर को मारने के बजाय, नए के साथ --replaceया -replaceयदि उपलब्ध हो तो चलाने का प्रयास करें ।

Comments

अगर मैं उपयोग करता --replaceहूं तो मुझे हमेशा एक चेतावनी मिलती है another window manager is already running। इससे मुझे कोई मतलब नहीं है।

— watain

Answer 11

while :; do read; done

बच्चे के सोने की प्रक्रिया का इंतजार नहीं करना।

Comments

stdinयदि यह अभी भी होता है तो इससे जुड़ा होता है tty। यदि आप < /dev/nullइसे व्यस्त-छोरों के साथ चलाते हैं । यह कुछ स्थितियों में कुछ काम का हो सकता है, इसलिए मैं नीचे नहीं जाता।

— टीनो

यह एक बहुत बुरा विचार है, यह बस सीपीयू के आवंटन का उपभोग करेगा।

— मोहम्मद नौरेलिन