कार्यक्रमात विराम देतो

१.Thread.sleep()

तुम्ही जावा प्रोग्रामच्या अंमलबजावणीमध्ये विराम घालू शकता. हे सहसा आवश्यक नसते, कारण वापरकर्त्यांना त्यांचे प्रोग्राम शक्य तितक्या लवकर चालवायचे असतात. जर तुम्ही मुद्दाम तुमचा कोड कमी केला तर बरेच लोक आनंदी होणार नाहीत.

परंतु प्रोग्रामर म्हणून, अशा अनेक परिस्थिती असू शकतात ज्यात तुमच्या कोडमधील विराम उपयुक्त ठरेल. उदाहरणार्थ, समजा, तुम्ही एक गेम लिहित आहात आणि तुम्हाला दर दोन सेकंदांनी किंवा सेकंदातून अनेक वेळा काहीतरी करायचे आहे.

मूलभूतपणे, विराम उपयुक्त आहेत, म्हणून आपल्या कोडमध्ये विराम कसा जोडायचा ते पाहू. हे खरोखर खूप सोपे आहे:

Thread.sleep(duration);

duration विरामाची लांबी मिलिसेकंदात कुठे आहे ( 1/1000एक सेकंदाची).

हे विधान तुमच्या प्रोग्रामला मिलिसेकंदांसाठी विराम देईल duration . उदाहरणे:

Thread.sleep(2000);

Thread.sleep(500);

Thread.sleep(60 * 60 * 1000);

ते सराव मध्ये कसे वापरले जाऊ शकते ते येथे आहे. समजा आम्ही एक प्रोग्राम लिहित आहोत जो स्पेसशिप लाँच करेल. कोड असा दिसू शकतो:

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

System.out.println("Let'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 घेते. तुम्हाला ही क्रिया प्रति सेकंद ५ वेळा करायची आहे. आपण किती वेळ थांबावे? निश्चितपणे 200ms नाही.

प्रति सेकंद 5 वेळा कृती करण्यासाठी, आम्हाला क्रिया अंमलात आणण्यासाठी लागणारा वेळ आणि विराम कालावधी 200 ms इतका असणे आवश्यक आहे. जर आपण असे केले तर ते सेकंदाला 5 वेळा धावेल. आमच्या बाबतीत, क्रियेसाठी 100 ms आवश्यक आहे, याचा अर्थ विराम देण्यासाठी 100 ms शिल्लक आहेत.

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

गेम डेव्हलपर्सना या वस्तुस्थितीची चांगली जाणीव आहे की कृती अंमलात आणण्यासाठी लागणारा वेळ शून्यापेक्षा खूप जास्त आहे. आणि खेळ खेळणारे लोकही असेच असतात.

जर एखादा गेम 20 FPS वर चालत असेल, तर याचा अर्थ तो एका सेकंदात स्क्रीनवर फक्त 20 फ्रेम्स काढू शकतो. 1000/2050 ms मिळते. गेम खेळताना फ्रेम काढण्यासाठी हा वेळ लागतो.

3. नॅनोसेकंद

जावा तयार झाला त्यापेक्षा आज संगणक खूप वेगवान आहेत. याचा अर्थ असा की 1 मिलीसेकंदचा विराम पुरेसा दाणेदार असू शकत नाही.

समजा आपल्याकडे काही अति संक्षिप्त क्रिया आहे जी आपल्याला प्रति सेकंद 2000 वेळा करायची आहे. अर्धा मिलीसेकंद कसे थांबवायचे?

यासाठी, पद्धतीचा आणखी एक प्रकार आहे Thread.sleep():

Thread.sleep(milliseconds, nanoseconds);

ही पद्धत निर्दिष्ट प्रमाणात मिलिसेकंद आणि नॅनोसेकंदसाठी प्रोग्रामला झोपायला ठेवते.

नॅनोसेकंद हे मिलिसेकंदचा 1 दशलक्षवावा भाग आहे. याचा अर्थ असा की दीड मिलिसेकंदांचा विराम यासारखा दिसेल:

Thread.sleep(1, 500_000);

1/10आणि जर तुम्हाला मिलिसेकंदाचा विराम हवा असेल तर तुम्हाला हे लिहावे लागेल:

Thread.sleep(0, 100_000);

तुम्ही आत्ता तुमच्या प्रोग्राममध्ये ही पद्धत वापरत नसाल. परंतु त्याबद्दल जाणून घेणे आणि त्याबद्दल माहिती नसणे यापेक्षा ते न वापरणे चांगले आहे.

4. TimeUnitवर्ग

तसे, Java मध्ये आणखी एक वर्ग आहे जो तुम्ही तुमचा अर्ज कमी करण्याचा निर्णय घेतल्यास तुमचे जीवन सोपे करेल. आम्ही 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

या गुणधर्मांसह कार्य करणे अत्यंत सोयीचे आहे, कारण तासांना मिलिसेकंदमध्ये रूपांतरित करण्याचा विचार करण्याची गरज नाही. असे कोड लिहिणे आणि वाचणे अधिक आनंददायी आहे.