1.Thread.sleep()
మీరు జావా ప్రోగ్రామ్ యొక్క ఎగ్జిక్యూషన్లో పాజ్లను చొప్పించవచ్చు. వినియోగదారులు తమ ప్రోగ్రామ్లను వీలైనంత త్వరగా అమలు చేయాలని కోరుకుంటున్నందున ఇది సాధారణంగా అవసరం లేదు. మీరు ఉద్దేశపూర్వకంగా మీ కోడ్ని మందగిస్తే చాలా మంది సంతోషించలేరు.
కానీ ప్రోగ్రామర్గా, మీ కోడ్లో పాజ్ ఉపయోగపడే అనేక పరిస్థితులు ఉండవచ్చు. ఉదాహరణకు, మీరు గేమ్ వ్రాస్తున్నారని అనుకుందాం మరియు అది ప్రతి రెండు సెకన్లకు ఒకసారి లేదా సెకనుకు చాలా సార్లు ఏదైనా చేయాలని మీరు కోరుకుంటారు.
ప్రాథమికంగా, పాజ్లు ఉపయోగకరంగా ఉంటాయి, కాబట్టి మీ కోడ్కి పాజ్ను ఎలా జోడించాలో చూద్దాం. ఇది నిజానికి చాలా సులభం:
Thread.sleep(duration);
duration
పాజ్ యొక్క పొడవు మిల్లీసెకన్లలో ( 1/1000
సెకను) ఎక్కడ ఉంది.
ఈ ప్రకటన మీ ప్రోగ్రామ్ను మిల్లీసెకన్ల పాటు పాజ్ చేస్తుంది duration
. ఉదాహరణలు:
|
ప్రోగ్రామ్ను 2 సెకన్ల పాటు పాజ్ చేస్తుంది. |
|
ప్రోగ్రామ్ను సగం సెకను పాటు పాజ్ చేస్తుంది. |
|
ప్రోగ్రామ్ను 1 గంట పాటు పాజ్ చేస్తుంది. |
ఆచరణలో దీన్ని ఎలా ఉపయోగించవచ్చో ఇక్కడ ఉంది. స్పేస్షిప్ను ప్రారంభించే ప్రోగ్రామ్ను మేము వ్రాస్తున్నామని చెప్పండి. కోడ్ ఇలా కనిపించవచ్చు:
|
ప్రతి సెకను, ప్రోగ్రామ్ ఒక సంఖ్యను ప్రదర్శిస్తుంది: 10 , ఆపై 9 , ఆపై 8 , మొదలైనవి. కౌంట్ చేరుకున్నప్పుడు , ప్రోగ్రామ్ " " 0 ప్రదర్శిస్తుంది.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
ఈ లక్షణాలతో పని చేయడం చాలా సౌకర్యవంతంగా ఉంటుంది, ఎందుకంటే గంటలను మిల్లీసెకన్లుగా మార్చడం గురించి ఆలోచించాల్సిన అవసరం లేదు. ఇటువంటి కోడ్ రాయడానికి మరియు చదవడానికి చాలా ఆహ్లాదకరంగా ఉంటుంది.
GO TO FULL VERSION