1.Thread.sleep()

आप जावा प्रोग्राम के निष्पादन में विराम लगा सकते हैं। यह आम तौर पर आवश्यक नहीं है, क्योंकि उपयोगकर्ता चाहते हैं कि उनके प्रोग्राम जितनी जल्दी हो सके चलें। बहुत से लोग खुश नहीं होंगे यदि आप जानबूझकर अपना कोड धीमा कर दें।

लेकिन एक प्रोग्रामर के रूप में, ऐसी कई स्थितियाँ हो सकती हैं जहाँ आपके कोड में ठहराव उपयोगी होगा। उदाहरण के लिए, मान लीजिए कि आप एक गेम लिख रहे हैं और आप चाहते हैं कि यह हर दो सेकंड में एक बार या एक सेकंड में कई बार कुछ करे।

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

Thread.sleep(duration);

मिलीसेकंड ( एक सेकंड का) duration में ठहराव की लंबाई कहाँ है।1/1000

duration यह कथन आपके प्रोग्राम को मिलीसेकंड के लिए रोक देगा । उदाहरण:

Thread.sleep(2000);
 प्रोग्राम को 2 सेकंड के लिए रोक देता है। 
Thread.sleep(500);
 कार्यक्रम को आधे सेकेंड के लिए रोक देता है। 
Thread.sleep(60 * 60 * 1000);
 कार्यक्रम को 1 घंटे के लिए रोक देता है।
Java university

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

for (int i = 10; i > 0; i--)
{
   System.out.println(i);
   Thread.sleep(1000);
}

System.out.println("Let's go!");
 प्रत्येक सेकंड, प्रोग्राम एक नंबर प्रदर्शित करेगा: , फिर 10, 9फिर 8, आदि




।0Let's go!

2. विराम की सही गणना करना

ठहराव की अवधि की गणना करना आसान है। यदि आपको एक सेकंड में एक बार कुछ करने के लिए कार्यक्रम की आवश्यकता है, तो विराम 1000 ms है। यदि प्रति सेकंड 2 बार, तो 500ms (1000/2) के लिए रुकें।

यदि आपको प्रति सेकंड 15 बार कुछ करने की आवश्यकता है, तो 66 ms (1000/15) के लिए रुकें। यह सब अपेक्षाकृत सीधा लगता है:

The duration of one iteration of the loop = 1000 / number of times per second

लेकिन यहाँ एक बहुत ही महत्वपूर्ण बारीकियाँ है। हालांकि कई बयान बहुत तेजी से निष्पादित होते हैं, वे तात्कालिक नहीं होते हैं।

यह देखो। मान लीजिए कि आपके पास एक क्रिया है जिसे पूरा करने में 100ms लगते हैं। आप इस क्रिया को प्रति सेकंड 5 बार करना चाहते हैं। आपको कब तक रुकना चाहिए? निश्चित रूप से 200ms नहीं।

प्रति सेकंड 5 बार की जाने वाली क्रिया के लिए, हमें क्रिया को निष्पादित करने के लिए आवश्यक समय और ठहराव की अवधि 200 ms के बराबर होनी चाहिए। अगर हम ऐसा करते हैं, तो यह ठीक 5 बार प्रति सेकंड चलेगा। हमारे मामले में, कार्रवाई के लिए 100 एमएस की आवश्यकता होती है, जिसका अर्थ है कि ठहराव के लिए अभी भी 100 एमएस बाकी है।

pause duration = duration of one iteration of the loop - time required to execute the action

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

यदि कोई गेम 20 एफपीएस पर चलता है, तो इसका मतलब है कि यह एक सेकंड में स्क्रीन पर केवल 20 फ्रेम ही बना सकता है। 1000/2050 मि.से. यह गेम खेलते समय एक फ्रेम बनाने के लिए आवश्यक समय है।

3. नैनोसेकंड

जावा के निर्माण के समय की तुलना में आज के कंप्यूटर बहुत तेज हैं। इसका मतलब है कि 1 मिलीसेकंड का विराम पर्याप्त रूप से दानेदार नहीं हो सकता है।

मान लीजिए कि हमारे पास कुछ अति संक्षिप्त कार्य हैं जिन्हें हम प्रति सेकंड 2000 बार करना चाहते हैं। हम आधा मिलीसेकंड के लिए कैसे रुक सकते हैं?

इसके लिए, विधि का एक और प्रकार है Thread.sleep():

Thread.sleep(milliseconds, nanoseconds);

यह विधि प्रोग्राम को निर्दिष्ट मात्रा में मिलीसेकंड और नैनोसेकंड के लिए सोने के लिए रखती है।

नैनोसेकंड एक मिलीसेकंड का 10 लाखवां हिस्सा होता है। इसका मतलब है कि डेढ़ मिलीसेकंड का विराम इस तरह दिखेगा:

Thread.sleep(1, 500_000);

और यदि आप एक मिलीसेकंड का विराम चाहते हैं 1/10, तो आपको यह लिखना होगा:

Thread.sleep(0, 100_000);

हो सकता है कि आप अभी इस पद्धति का उपयोग अपने कार्यक्रमों में नहीं कर रहे हों। लेकिन इसके बारे में जानना और इसका उपयोग न करना बेहतर है बजाय इसके कि इसकी आवश्यकता हो और इसके बारे में न पता हो।

4. TimeUnitवर्ग

वैसे, जावा में एक और वर्ग है जो आपके आवेदन को धीमा करने का निर्णय लेने पर आपके जीवन को आसान बना देगा। हम पैकेज TimeUnitमें क्लास के बारे में बात कर रहे हैं java.util.concurrent।

याद रखें कि चूंकि कक्षा java.langपैकेज में नहीं है, तो आपको या तो लाइन जोड़ने की जरूरत है import java.util.concurrent.TimeUnit;, या java.util.concurrent.TimeUnitहर बार अपने कोड में लिखना होगा।

यह वर्ग वही काम करता है जो Thread.sleep(), लेकिन यह अधिक सुविधाजनक है:

TimeUnit.HOURS.sleep(15)

यह कोड आपके प्रोग्राम को 15 घंटे के लिए निष्क्रिय कर देगा। मिनट, सेकंड, दिन भी उपलब्ध हैं। साथ ही माइक्रोसेकंड (1/1000,000) और नैनोसेकंड (1/1000,000,000)।

वर्ग TimeUnit में निम्नलिखित गुण हैं:

  • नैनोसेकंड:NANOSECONDS
  • माइक्रोसेकंड:MICROSECONDS
  • मिलीसेकंड:MILLISECONDS
  • सेकंडSECONDS
  • मिनट:MINUTES
  • घंटे:HOURS
  • दिन:DAYS

इन गुणों के साथ काम करना बेहद सुविधाजनक है, क्योंकि घंटों को मिलीसेकंड में बदलने के बारे में सोचने की कोई जरूरत नहीं है। ऐसा कोड लिखने और पढ़ने के लिए और अधिक सुखद है।

अधिक विवरण यहां पढ़ा जा सकता है ।