ప్రోగ్రామ్‌లో పాజ్‌లు

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 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 ms అవసరం, అంటే పాజ్ కోసం ఇంకా 100 ms మిగిలి ఉంది.

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

గేమ్ డెవలపర్‌లకు ఒక చర్యను అమలు చేయడానికి అవసరమైన సమయం సున్నా కంటే చాలా ఎక్కువ అనే వాస్తవం గురించి బాగా తెలుసు . అలాగే ఆటలు ఆడేవారు కూడా.

ఒక గేమ్ 20 FPS వద్ద నడుస్తుంటే, అది ఒక సెకనులో స్క్రీన్‌పై కేవలం 20 ఫ్రేమ్‌లను మాత్రమే డ్రా చేయగలదని అర్థం. 1000/20దిగుబడి 50 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తరగతి

మార్గం ద్వారా, మీరు మీ అప్లికేషన్‌ను నెమ్మదించాలని నిర్ణయించుకుంటే మీ జీవితాన్ని సులభతరం చేసే మరొక తరగతి జావాలో ఉంది. 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

ఈ లక్షణాలతో పని చేయడం చాలా సౌకర్యవంతంగా ఉంటుంది, ఎందుకంటే గంటలను మిల్లీసెకన్లుగా మార్చడం గురించి ఆలోచించాల్సిన అవసరం లేదు. ఇటువంటి కోడ్ రాయడానికి మరియు చదవడానికి చాలా ఆహ్లాదకరంగా ఉంటుంది.

మరిన్ని వివరాలను ఇక్కడ చదవవచ్చు .