நிரலில் இடைநிறுத்தப்படுகிறது

1.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 எம்.எஸ். வினாடிக்கு 2 முறை என்றால், 500ms (1000/2) க்கு இடைநிறுத்தவும்.

நீங்கள் ஒரு வினாடிக்கு 15 முறை ஏதாவது செய்ய வேண்டும் என்றால், 66 எம்எஸ் (1000/15) இடைநிறுத்தவும். இது எல்லாம் மிகவும் எளிமையானதாகத் தெரிகிறது:

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

ஆனால் இங்கே ஒரு மிக முக்கியமான நுணுக்கம் உள்ளது. பல அறிக்கைகள் மிக விரைவாக செயல்பட்டாலும், அவை உடனடியானவை அல்ல.

இதைப் பாருங்கள். 100 மி.எஸ்.களை முடிக்க வேண்டிய செயல் உங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். இந்த செயலை வினாடிக்கு 5 முறை செய்ய வேண்டும். எவ்வளவு நேரம் இடைநிறுத்த வேண்டும்? கண்டிப்பாக 200ms இல்லை.

செயலை ஒரு வினாடிக்கு 5 முறை செய்ய, செயலைச் செயல்படுத்த தேவையான நேரம் மற்றும் இடைநிறுத்த கால அளவு 200 எம்.எஸ்.க்கு சமமாக இருக்க வேண்டும். அப்படிச் செய்தால், அது ஒரு நொடிக்கு 5 முறை துல்லியமாக இயங்கும். எங்கள் விஷயத்தில், செயலுக்கு 100 எம்எஸ் தேவைப்படுகிறது, அதாவது இடைநிறுத்தத்திற்கு இன்னும் 100 எம்எஸ் உள்ளது.

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

ஒரு செயலைச் செய்யத் தேவைப்படும் நேரம் பூஜ்ஜியத்தை விட அதிகமாக இருக்கும் என்பதை கேம் டெவலப்பர்கள் நன்கு அறிவார்கள் . விளையாடுபவர்களும் அப்படித்தான்.

ஒரு விளையாட்டு 20 FPS இல் இயங்கினால், அது ஒரு நொடியில் 20 பிரேம்களை மட்டுமே திரையில் வரைய முடியும். 1000/2050 எம்.எஸ். விளையாட்டை விளையாடும் போது ஒரு சட்டத்தை வரைய வேண்டிய நேரம் இது .

3. நானோ வினாடிகள்

ஜாவா உருவாக்கப்பட்ட காலத்தை விட இன்று கணினிகள் மிக வேகமாக உள்ளன. அதாவது 1 மில்லி வினாடி இடைநிறுத்தம் போதுமான அளவு சிறுமணியாக இருக்காது.

நாம் ஒரு வினாடிக்கு 2000 முறை செய்ய விரும்பும் சில சூப்பர் சுருக்கமான செயல்கள் உள்ளன என்று வைத்துக்கொள்வோம். அரை மில்லி விநாடிகளுக்கு எப்படி இடைநிறுத்துவது?

இதற்கு, முறையின் மற்றொரு மாறுபாடு உள்ளது Thread.sleep():

Thread.sleep(milliseconds, nanoseconds);

இந்த முறை நிரலை குறிப்பிட்ட மில்லி விநாடிகள் மற்றும் நானோ விநாடிகளுக்கு தூங்க வைக்கிறது.

நானோ விநாடிகள் ஒரு மில்லி வினாடியில் 1 மில்லியன். அதாவது ஒன்றரை மில்லி விநாடிகளின் இடைநிறுத்தம் இப்படி இருக்கும்:

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

இந்த பண்புகளுடன் பணிபுரிவது மிகவும் வசதியானது, ஏனெனில் மணிநேரத்தை மில்லி விநாடிகளாக மாற்றுவது பற்றி சிந்திக்க வேண்டிய அவசியமில்லை. அத்தகைய குறியீடு எழுதவும் படிக்கவும் மிகவும் இனிமையானது.

மேலும் விவரங்களை இங்கே படிக்கலாம் .