"హలో, అమిగో! ఈ రోజు మనం ఒక చిన్న కానీ ఆసక్తికరమైన పాఠాన్ని కలిగి ఉంటాము. నేను మీకు దిగుబడి గురించి చెప్పబోతున్నాను , థ్రెడ్ క్లాస్ యొక్క స్టాటిక్ పద్ధతి."
ప్రాసెసర్ నిరంతరం థ్రెడ్‌ల మధ్య మారుతుందని ఎల్లీ ఇప్పటికే మీకు చెప్పారు. ప్రతి థ్రెడ్‌కు ఒక చిన్న ప్రాసెసర్ సమయం కేటాయించబడుతుంది, దీనిని క్వాంటం అని పిలుస్తారు . ఈ సమయం ముగిసినప్పుడు, ప్రాసెసర్ మరొక థ్రెడ్‌కు మారుతుంది మరియు దాని ఆదేశాలను అమలు చేయడం ప్రారంభిస్తుంది. కాలింగ్ Thread.yield()ప్రస్తుత థ్రెడ్ క్వాంటంను ముందుగానే ముగించడానికి మిమ్మల్ని అనుమతిస్తుంది. మరో మాటలో చెప్పాలంటే, ఇది తదుపరి థ్రెడ్‌కు మారమని ప్రాసెసర్‌కు చెబుతుంది.
"అయితే ఒక థ్రెడ్ దాని సమయాన్ని మరొక థ్రెడ్‌కి ఎందుకు వదులుకోవాలి?"
"ఇది తరచుగా జరగదు. దిగుబడిని పిలవడం అంటే «మా థ్రెడ్ షెడ్యూల్ కంటే ముందుగానే పూర్తి అవుతుంది» మరియు దిగుబడి తర్వాత కమాండ్ పూర్తి సమయం క్వాంటంతో ప్రారంభమవుతుంది. అందువలన, ఇది అంతరాయం కలిగించే అవకాశాలు తక్కువగా ఉంటాయి. ప్రత్యేకించి ఇది చిన్న కమాండ్ అయితే, అది అమలు చేయడానికి ఎక్కువ సమయం పట్టదు. కొన్ని ప్రక్రియలను ఆప్టిమైజ్ చేయడానికి ఈ విధానాన్ని ఉపయోగించవచ్చు."
Thread.sleep(0) నిజానికి అదే విధంగా పనిచేస్తుందని కూడా నేను మీకు చెప్పగలను . మీరు మొదట దిగుబడి పద్ధతిని ఎక్కువగా ఉపయోగించరని నేను భావిస్తున్నాను , కానీ దాని గురించి తెలుసుకోవడం ఉపయోగకరంగా ఉంటుంది.
GO TO FULL VERSION