රැඳී සිටීම () සහ නින්ද () අතර වෙනස

A wait()සහ sleep()Threads අතර වෙනස කුමක්ද?

wait()-Ing Thread තවමත් ධාවන මාදිලියේ පවතින අතර CPU චක්‍ර භාවිතා කරන නමුත් sleep()-ing කිසිදු CPU චක්‍රයක් පරිභෝජනය නොකරන බව මගේ අවබෝධය නිවැරදිද?

අපට දෙකම ඇත්තේ ඇයි wait()සහ sleep(): ඒවා ක්‍රියාත්මක කිරීම පහළ මට්ටමින් වෙනස් වන්නේ කෙසේද?

ඒ waitකැඳවීම තවත් නූල් විසින් "දක්වා අවදිවූවකු" කළ හැකි notifyෙහයින් මත බලා කෙරෙන මොනිටරය මත sleepබෑ. ද wait(සහ notify) වාරණ සිදු කළ යුතුය synchronizedෙහයින් වස්තුව මොනිටරය මත sleepනොවේ:

Object mon = ...;
synchronized (mon) {
    mon.wait();
} 

මෙම අවස්ථාවෙහිදී දැනට ක්‍රියාත්මක වන නූල් එක බලා මොනිටරය මුදා හරියි . තවත් නූලක් කළ හැකිය

synchronized (mon) { mon.notify(); }

(එම මත monවස්තුව) සහ ප්රථම නූල් (එය මොනිටරය බලා එකම නූල් යැයි උපකල්පනය) අවදි කරනු ඇත.

notifyAllඑක් නූල් එකකට වඩා මොනිටරයේ රැඳී සිටී නම් ඔබට ඇමතිය හැකිය - මෙය ඔවුන් සියල්ලන්ම අවදි කරනු ඇත . කෙසේ වෙතත්, එක් නූල් එකකට පමණක් මොනිටරය අල්ලා ගැනීමට හැකි වනු ඇත ( waitඑය synchronizedබ්ලොක් එකක ඇති බව මතක තබා ගන්න ) සහ ඉදිරියට ගෙනයන්න - අනෙක් ඒවා මොනිටරයේ අගුල ලබා ගන්නා තෙක් අවහිර කරනු ලැබේ.

තවත් අවස්ථාවක ඔබට කතා බව ය waitමත Object(ඔබ වස්තුවක් ගේ මොනිටරය මත බලා එනම්) ඔබ කතා ෙහයින්ද, ම sleepමත Thread.

තවත් අවස්ථාවක ඔබ විසින් ලබා ගත හැකි බව ය ව්යාජ wakeups සිට wait(එනම් කිසිදු පැහැදිලි හේතුවකින් තොරව ජීව දත්ත බලා ලබන නූල්). ඔබ සෑම විටමwait පහත සඳහන් පරිදි යම් කොන්දේසියක් මත භ්‍රමණය විය යුතුය :

synchronized {
    while (!condition) { mon.wait(); }
}

තවම සඳහන් කර නැති එක් ප්‍රධාන වෙනසක් නම්, නූල් එකක් නිදා සිටියදී එය තබා ඇති අගුල් මුදා නොහරින අතර, බලා සිටින අතරතුර wait()කැඳවූ වස්තුවෙහි අගුල මුදා හරිනු ඇත.

synchronized(LOCK) {
    Thread.sleep(1000); // LOCK is held
}


synchronized(LOCK) {
    LOCK.wait(); // LOCK is not held
}

මට මෙම ලිපිය ප්‍රයෝජනවත් විය. එය අතර වෙනස තබන Thread.sleep(), Thread.yield()සහ Object.wait()මානව දී ය. උපුටා දැක්වීමට:

මේ සියල්ලම අවසානයේදී මෙහෙයුම් පද්ධතියේ උපලේඛකයා වෙතට යොමු වන අතර එමඟින් ක්‍රියාවලි සහ නූල් සඳහා කාලරාමු ලබා දේ.

sleep(n)පවසයි "මම මගේ timeslice සමග සිදු කරනවා, සහ මට කරුණාකර අවම වශයෙන් n තත්පර සඳහා තවත් එක් දෙන්න එපා." ඉල්ලූ කාලය ගෙවී යන තුරු මෙහෙයුම් පද්ධතිය නිදි නූල් උපලේඛනගත කිරීමට උත්සාහ නොකරයි.

yield()පවසයි "මම මගේ timeslice සමග සිදු කරනවා, නමුත් මම තවමත් වැඩ තියෙනවා කරන්න." මෙහෙයුම් පද්ධතියට එකවරම නූල් ටයිම් ලයිස් එකක් ලබා දීමට හෝ වෙනත් නූල් එකක් දීමට හෝ සීපීයූ ක්‍රියාවට නැංවීමට නිදහස ඇත.

wait()පවසයි "මම මගේ timeslice සමග සිදු කරනවා. කවුරුහරි දැනුම් දීමක් කරන තුරු මට වෙනත් කාල සටහනක් දෙන්න එපා. ” සමග මෙන් sleep(), මෙම මෙහෙයුම් පද්ධතිය පවා කෙනෙකු ඇමතුම් මිස ඔබේ කාර්යය සැලසුම් කිරීමට උත්සාහ නැහැ notify()(හෝ වෙනත් wakeup අවස්ථාවන්හීදී කිහිපයක් එක් සිදුවේ).

IO අවහිර කිරීම සහ වෙනත් තත්වයන් කිහිපයක් යටතේ නූල් වලට ඒවායේ කාලරාමුවෙහි ඉතිරි කොටසද අහිමි වේ. සමස්ත කාලරාමුව හරහා නූල් ක්‍රියා කරන්නේ නම්, මෙහෙයුම් පද්ධතිය බලහත්කාරයෙන් yield()කැඳවනු ලැබූ ආකාරයට පාලනය කරයි , එවිට වෙනත් ක්‍රියාදාමයන් ක්‍රියාත්මක විය හැකිය.

ඔබට අවශ්‍ය වන්නේ කලාතුරකිනි yield(), නමුත් ඔබට තාර්කික කාර්ය සීමාවන් සහිත ගණනය කළ හැකි යෙදුමක් තිබේ නම්, පද්ධතියක් ප්‍රතිචාර දැක්වීම වැඩි දියුණු කළ yield() හැකිය (කාලය වියදමින් - සන්දර්භය ස්විචයන්, මෙහෙයුම් පද්ධතියට සහ පසුපසට පවා නොමිලේ නොවේ). සෑම විටම මෙන් ඔබ සැලකිලිමත් වන ඉලක්ක මැනීම සහ පරීක්ෂා කිරීම.

මෙහි පිළිතුරු රාශියක් ඇතත් කිසිවක් ගැන සඳහන් කර ඇති අර්ථකථන වෙනස මට සොයාගත නොහැකි විය.

එය නූල් ගැනම නොවේ; මෙම ක්‍රම දෙකම අවශ්‍ය වන්නේ ඒවා එකිනෙකට වෙනස් භාවිත අවස්ථා සඳහා සහාය වන බැවිනි.

sleep()පෙර පරිදිම නූල් නින්දට යවයි, එය සන්දර්භය ඇසුරුම් කර පූර්ව නිශ්චිත කාලයක් සඳහා ක්‍රියාත්මක කිරීම නවත්වයි. එබැවින් නියමිත වේලාවට පෙර එය අවදි කිරීමට නම්, ඔබ නූල් යොමුව දැන සිටිය යුතුය. මෙය බහු නූල් පරිසරයක පොදු තත්වයක් නොවේ. එය බොහෝ විට කාල සමමුහුර්තකරණය සඳහා භාවිතා කරයි (උදා: හරියටම තත්පර 3.5 කින් අවදි වීම) සහ / හෝ දෘඩ කේත සහිත සාධාරණත්වය (ටික වේලාවක් නිදාගෙන අනෙක් අයට නූල් වැඩ කිරීමට ඉඩ දෙන්න).

wait(), ඊට පටහැනිව, නූල් (හෝ පණිවිඩ) සමමුහුර්තකරණ යාන්ත්‍රණයක් වන අතර එමඟින් ඔබට ගබඩා කර ඇති සඳහනක් (හෝ රැකවරණයක්) නොමැති ත්‍රෙඩ් එකක් දැනුම් දීමට ඉඩ ලබා දේ. ඔබට එය ප්‍රකාශන-දායක රටාවක් ලෙස සිතිය හැකිය ( wait== දායකත්වය සහ notify()== ප්‍රකාශනය). මූලික වශයෙන් දැනුම්දීම () භාවිතා කරමින් ඔබ පණිවිඩයක් යවනවා (එය කිසිසේත් නොලැබෙන අතර සාමාන්‍යයෙන් ඔබ ගණන් ගන්නේ නැත).

සාරාංශයක් ලෙස, ඔබ සාමාන්‍යයෙන් sleep()කාල සමමුහුර්තකරණය සහ wait()බහු-නූල්-සමමුහුර්තකරණය සඳහා භාවිතා කරයි.

ඒවා යටින් පවතින මෙහෙයුම් පද්ධතියේ එකම ආකාරයකින් ක්‍රියාත්මක කළ හැකිය, නැතහොත් නැත (ජාවා හි පෙර සංස්කරණවල සැබෑ බහු තෙරපුමක් නොතිබූ බැවින් සමහර කුඩා වීඑම් යන්ත්‍රද එසේ නොකරයි). ජාවා VM මත ධාවනය වන බව අමතක නොකරන්න, එවිට ඔබේ කේතය ක්‍රියාත්මක වන VM / OS / HW අනුව වෙනස් ආකාරයකින් පරිවර්තනය වේ.

මෙන්න, මම ක්‍රම wait()සහ sleep()ක්‍රම අතර වැදගත් වෙනස්කම් කිහිපයක් ලැයිස්තුගත කර ඇත .
PS: පුස්තකාල කේතය බැලීමට සබැඳි මත ක්ලික් කරන්න (අභ්‍යන්තර වැඩ කිරීම, වඩා හොඳ අවබෝධයක් සඳහා ටිකක් සෙල්ලම් කරන්න).

රැඳී සිටින්න ()

1. wait() ක්‍රමය මඟින් අගුල මුදා හරිනු ලැබේ.
2. wait()Objectපන්තියේ ක්‍රමයයි .
3. wait() ස්ථිතික නොවන ක්‍රමය - public final void wait() throws InterruptedException { //...}
4. wait()notify()හෝ notifyAll()ක්‍රම මගින් දැනුම් දිය යුතුය .

5. wait() ව්‍යාජ අනතුරු ඇඟවීමක් සමඟ කටයුතු කිරීම සඳහා ක්‍රමවේදය ලූපයකින් කැඳවිය යුතුය.

6. wait() ක්‍රමය සමමුහුර්ත සන්දර්භයෙන් (එනම් සමමුහුර්ත ක්‍රමය හෝ වාරණය) කැඳවිය යුතුය, එසේ නොමැති නම් එය විසි කරයි IllegalMonitorStateException

නින්ද ()

1. sleep() ක්‍රමය අගුල නිදහස් නොකරයි.
2. sleep()java.lang.Threadපන්තියේ ක්‍රමයයි .
3. sleep() ස්ථිතික ක්‍රමය - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. නියමිත කාල sleep()සීමාව අවසන් වූ පසු.
5. sleep()ලූපයෙන් ඇමතීම වඩා හොඳය (එනම් පහත කේතය බලන්න ).
6. sleep()ඕනෑම තැනක සිට කැඳවිය හැක. නිශ්චිත අවශ්‍යතාවයක් නොමැත.

Ref: රැඳී සිටීම සහ නින්ද අතර වෙනස

ඇමතුම් රැඳී සිටීම සහ නිදාගැනීමේ ක්‍රමය සඳහා කේත ස්නිපටය

synchronized(monitor){
    while(condition == true){ 
        monitor.wait()  //releases monitor lock
    }

    Thread.sleep(100); //puts current thread on Sleep    
}

රැඳී සිටීම සහ නිදාගැනීම පිළිබඳ වැඩ කිරීමෙන් පසු මම නිගමනය කරන වෙනස්කම් කිහිපයක් තිබේ, පළමුව බලා සිටීම () සහ නින්ද () භාවිතා කරමින් නියැදිය දෙස බලන්න:

උදාහරණ 1 : රැඳී සිටීම () සහ නින්ද () භාවිතා කිරීම:

synchronized(HandObject) {
    while(isHandFree() == false) {
        /* Hand is still busy on happy coding or something else, please wait */
        HandObject.wait();
    }
}

/* Get lock ^^, It is my turn, take a cup beer now */
while (beerIsAvailable() == false) {
    /* Beer is still coming, not available, Hand still hold glass to get beer,
       don't release hand to perform other task */
    Thread.sleep(5000);
}

/* Enjoy my beer now ^^ */
drinkBeers();

/* I have drink enough, now hand can continue with other task: continue coding */
setHandFreeState(true);
synchronized(HandObject) {
    HandObject.notifyAll();
}

ප්‍රධාන සටහන් කිහිපයක් පැහැදිලි කිරීමට ඉඩ දෙන්න:

1. අමතන්න :
   • රැඳී සිටින්න (): හෑන්ඩ් ඕබෙක්ට් වස්තුව රඳවා ඇති වත්මන් නූල් අමතන්න
   • නින්ද (): ත්‍රෙඩ් ක්‍රියාත්මක කිරීමේ කාර්යය සඳහා බියර් ලබා ගන්න (පන්ති ක්‍රමය වන බැවින් වත්මන් ධාවන නූලට එය බලපායි)
2. සමමුහුර්ත :
   • රැඳී සිටින්න (): සමමුහුර්ත කළ විට එකම වස්තුව (හෑන්ඩ් ඕබෙක්ට්) (නූල් එකකට වඩා වැඩි ගණනක් අතර සන්නිවේදනය අවශ්‍ය වූ විට (නූල් ක්‍රියාත්මක කිරීම කේතනය කිරීම, නූල් ක්‍රියාත්මක කිරීම බියර් ලබා ගැනීම) එකම වස්තුවකට ප්‍රවේශය අත්පොත)
   • නින්ද (): දිගටම ක්‍රියාත්මක කිරීමට බලා සිටින විට (බියර් රැඳී සිටීම)
3. අගුල තබා ගන්න :
   • රැඳී සිටින්න (): වෙනත් වස්තුවක් සඳහා අගුල මුදා හරින්න (හෑන්ඩ් ඕබෙක්ට් නොමිලේ, ඔබට වෙනත් කාර්යයක් කළ හැකිය)
   • නින්ද (): අවම වශයෙන් වාර ගණනක්වත් (හෝ බාධා වන තුරු) අගුලු දමා තබන්න (මගේ කාර්යය තවමත් අවසන් වී නැත, මම දිගටම අගුලු දමා සිටිමි.
4. අවදි වීමේ තත්වය :
   • රැඳී සිටින්න (): ඇමතුම දැනුම් දෙන තුරු (), වස්තුවෙන් දැනුම් දෙන්න
   • නින්ද (): අවම වශයෙන් කාලය ඉකුත්වන තුරු හෝ ඇමතුම බාධා කරන තෙක්
5. එස්තනි දැක්වෙන පරිදි අවසාන කරුණ භාවිතා වේ :

ඔබ සාමාන්‍යයෙන් කාල සමමුහුර්තකරණය සඳහා නින්ද () භාවිතා කරන අතර බහු-නූල් සමමුහුර්තකරණය සඳහා රැඳී සිටින්න.

මම වැරදියි නම් කරුණාකර මාව නිවැරදි කරන්න.

රැඳී සිටීම () සහ නින්ද () අතර වෙනස

• මූලික වෙනස නම් wait()වෙතින් වන Objectඅතර sleep()ස්ථිතික ක්රමය වේ Thread.

• ප්රධාන වෙනස නම් wait()නිකුත් අගුල අතර sleep()අපේක්ෂා කරන අතරතුර කිසිදු අගුල නැත.

• wait()අන්තර්-නූල් සන්නිවේදනය sleep()සඳහා භාවිතා කරන අතර සාමාන්‍යයෙන් ක්‍රියාත්මක කිරීම සඳහා විරාමයක් හඳුන්වා දීමට භාවිතා කරයි.

• wait() ඕනෑම තැනක සිට කැඳවිය හැකි IllegalMonitorStateExceptionඅතර සමමුහුර්තකරණය ඇතුළත සිට sleep()කැඳවිය යුතුය.

• සිට නැවත නූල් ආරම්භ කිරීමට wait(), ඔබ කතා කරන්න වෙනවා notify()හෝ notifyAll(). සඳහා පරිදි sleep(),පොට නිශ්චිත කාල පරතරය පසු ආරම්භ වී යයි.

සමානකම්

• දෙකම වත්මන් නූල් ධාවනය කළ නොහැකි තත්වයට ගෙන යයි.
• දෙකම ස්වදේශීය ක්‍රම වේ.

මෙය ඉතා සරල ප්‍රශ්නයකි, මන්ද මෙම ක්‍රම දෙකම මුළුමනින්ම වෙනස් භාවිතයක් ඇති බැවිනි.

ප්‍රධාන වෙනස වන්නේ නින්ද කිසිදු අගුලක් හෝ මොනිටරයක් ​​නිකුත් නොකරන අතර අගුල හෝ මොනිටරය මුදා හැරීමට බලා සිටීමයි. අන්තර් නූල් සන්නිවේදනය සඳහා රැඳී සිටීම භාවිතා කරන අතර ක්‍රියාත්මක කිරීම සඳහා විරාමයක් හඳුන්වා දීම සඳහා නින්ද භාවිතා කරයි.

මෙය පැහැදිලි හා මූලික පැහැදිලි කිරීමක් පමණි, ඔබට ඊට වඩා වැඩි යමක් අවශ්‍ය නම් දිගටම කියවන්න.

වූ අවස්ථාවක wait()ක්රමය නූල් රාජ්ය බලා යනවා අපි කතා තුරු එය ස්වයංක්රීයව නැවත එන්නේ නැහැ notify()ක්රමය (හෝ notifyAll()ඔබ රාජ්ය බලා එක් නූල් වඩා අවශ්යනම් ඔබ එම නූල් සියලු අවදි කිරීමට අවශ්ය නම්). ඔබ සමමුහුර්ත හෝ වස්තුව අගුලු හෝ ප්රවේශ පන්තියේ අගුලු අවශ්ය wait()හෝ notify()හෝ notifyAll()ක්රම. තවත් එක් දෙයක් නම්, wait()අන්තර් නූල් සන්නිවේදනය සඳහා මෙම ක්‍රමය භාවිතා කරනු ලැබේ, මන්ද නූල් පොරොත්තු තත්වයට ගියහොත් ඔබට එම නූල අවදි කිරීමට තවත් නූල් අවශ්‍ය වේ.

නමුත් sleep()මෙය ක්‍රියාවලිය තත්පර කිහිපයක් හෝ ඔබට අවශ්‍ය කාලය රඳවා තබා ගැනීමට භාවිතා කරන ක්‍රමයකි. එම නූල නැවත ලබා ගැනීම සඳහා ඔබට කිසිදු ක්‍රමයක් notify()හෝ notifyAll()ක්‍රමයක් ප්‍රකෝප කිරීමට අවශ්‍ය නොවන බැවිනි. නැතහොත් එම ත්‍රෙඩ් එක නැවත කැඳවීමට ඔබට වෙනත් නූල් අවශ්‍ය නොවේ. පරිශීලකයාගේ වාරයෙන් පසුව තත්පර කිහිපයකින් යම් දෙයක් සිදුවිය යුතු යැයි ඔබට අවශ්‍ය නම්, පරිගණකය වාදනය වන තෙක් පරිශීලකයා බලා සිටීමට ඔබට අවශ්‍ය නම් ඔබට එම sleep()ක්‍රමය සඳහන් කළ හැකිය .

සම්මුඛ සාකච්ඡා බොහෝ විට ඉල්ලා ඇති තවත් එක් වැදගත් වෙනසක්: sleep()අයත් Threadපන්තිය හා wait()අයිති Objectපන්තියේ.

මේ සියල්ල අතර sleep()සහ wait().

මෙම ක්‍රම දෙකම අතර සමානකමක් තිබේ: ඒවා දෙකම ප්‍රකාශිත පරීක්‍ෂා කර ඇති බැවින් ඔබට මෙම ක්‍රම වෙත ප්‍රවේශ වීමට උත්සාහ කිරීම හෝ විසි කිරීම අවශ්‍ය වේ.

මෙය ඔබට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

මූලාශ්‍රය: http://www.jguru.com/faq/view.jsp?EID=47127

Thread.sleep()වත්මන් නූල් යම් කාලයක් සඳහා "ධාවනය කළ නොහැකි" තත්වයට යවයි . නූල් එය අත්පත් කර ගත් මොනිටර තබා ගනී - එනම් නූල් දැනට සමමුහුර්ත කොටසේ හෝ ක්‍රමයක තිබේ නම් වෙනත් කිසිදු නූලකට මෙම කොටස හෝ ක්‍රමයට ඇතුළු විය නොහැක. තවත් නූලක් ඇමතුමක් ලැබුවහොත් t.interrupt()එය නිදා සිටින නූල් අවදි කරයි.

නින්ද යනු ස්ථිතික ක්‍රමයක් බව සලකන්න, එයින් අදහස් කරන්නේ එය සෑම විටම වත්මන් නූල් වලට බලපාන බවයි (නින්දේ ක්‍රමය ක්‍රියාත්මක කරන ක්‍රමය). පොදු වැරැද්දක් නම් t.sleep(), t යනු වෙනස් නූල් තැනකට ඇමතීමයි; එසේ වුවද, නිදාගන්නේ වර්තමාන නූල් මිස ටී නූල් නොවේ.

t.suspend()අතහැර දමා ඇත. එය භාවිතා කිරීමෙන් වත්මන් නූල් හැර වෙනත් නූලක් නතර කළ හැකිය. අත්හිටවූ නූල් එහි සියලුම මොනිටරයන් තබා ඇති අතර මෙම තත්වය බාධා කළ නොහැකි බැවින් එය අවහිරතා ඇති වේ.

object.wait()වත්මන් නූල් "ධාවනය කළ නොහැකි" තත්වයට යවයි , වැනි sleep(), නමුත් පෙරළීමකින් . රැඳී සිටීම හැඳින්වෙන්නේ වස්තුවක් මත මිස නූල්වලින් නොවේ; අපි මෙම වස්තුව "අගුළු වස්තුව" ලෙස හඳුන්වමු. lock.wait()කැඳවීමට පෙර , වත්මන් නූල් අගුළු වස්තුව මත සමමුහුර්ත කළ යුතුය; wait() ඉන්පසු මෙම අගුල මුදා හරින අතර අගුල හා සම්බන්ධ "පොරොත්තු ලේඛනයට" නූල් එක් කරයි. පසුව, තවත් නූලකට එකම අගුළු වස්තුව හා සමමුහුර්තකරණය කළ හැකිය lock.notify(). මෙය මුල්, පොරොත්තු නූල් අවදි කරයි. මූලික වශයෙන්, wait()/ notify()වැනි sleep()/ interrupt(), ක්‍රියාකාරී නූල් වලට පමණක් නිදි නූල් වෙත සෘජු දර්ශකයක් අවශ්‍ය නොවේ, නමුත් හවුල් අගුළු වස්තුවට පමණි.

රැඳී සිටීම සහ නිදාගැනීම වෙනස් කරුණු දෙකකි:

• දී sleep()පොට එම නිශ්චිත කාලය සඳහා වැඩ නතර වෙනවා.
• දී wait()එම වස්තුව බලා මත තෙක් සාමාන්යයෙන් අනෙක් නූල් විසින් දැනුම් ඇත පොට වැඩ නතර වෙනවා.

sleepක්රමයකි Thread, waitක්රමයකි Object, ඒ නිසා wait/notify(භාවිතා ජාවා හවුල් දත්ත ජාලා ශිල්පීය ක්රමය වේ මොනිටරය ), නමුත් sleepතමන් කරා යෑමටද නූල් කළ හැකි සරළ ක්රමයකි.

නින්ද () යනු ක්‍රියාවලිය තත්පර කිහිපයක් හෝ ඔබට අවශ්‍ය වේලාවට රඳවා තබා ගැනීමට භාවිතා කරන ක්‍රමයකි. නමුත් රැඳී සිටීමේ () ක්‍රමයේ නූල් රැඳී සිටීමේ තත්වයට පත්වන අතර අප දැනුම් දීමේ () හෝ notifyAll ().

මෙම ප්රධාන වෙනස වන්නේ , බලා () බලා ඇති අතර නින්ද () ඕනෑම අගුලු හෝ අධීක්ෂණය නිදහස් කරන්නේ නැහැ අතර අගුල හෝ අධීක්ෂණය මුදාහරියි. අන්තර්-නූල් සන්නිවේදනය සඳහා රැඳී සිටීම භාවිතා කරන අතර නින්ද සාමාන්‍යයෙන් ක්‍රියාත්මක කිරීමේදී විරාමයක් හඳුන්වා දීම සඳහා යොදා ගනී.

Thread.sleep () වත්මන් නූල් “ධාවනය කළ නොහැකි” තත්වයට යම් කාලයක් සඳහා යවයි. නූල් එය අත්පත් කරගත් මොනිටර තබා ගනී - එනම් නූල් දැනට සමමුහුර්ත කොටසේ හෝ ක්‍රමයක තිබේ නම් වෙනත් කිසිදු නූලකට මෙම වාරණයට හෝ ක්‍රමයට ඇතුළු විය නොහැක. තවත් නූලක් t.interrupt () අමතන්නේ නම් එය නිදි නූල් අවදි කරයි. නින්ද යනු ස්ථිතික ක්‍රමයක් බව සලකන්න, එයින් අදහස් කරන්නේ එය සෑම විටම වත්මන් නූල් වලට බලපාන බවයි (නින්දේ ක්‍රමය ක්‍රියාත්මක කරන ක්‍රමය). පොදු වැරැද්දක් නම් t.sleep () ඇමතීමයි, එහිදී t යනු වෙනස් නූලක්; එසේ වුවද, නිදාගන්නේ වර්තමාන නූල් මිස ටී නූල් නොවේ.

object.night () නින්ද () වැනි “ධාවනය කළ නොහැකි” තත්වයට වත්මන් නූල් යවයි. රැඳී සිටීම හැඳින්වෙන්නේ වස්තුවක් මත මිස නූල්වලින් නොවේ; අපි මෙම වස්තුව “අගුළු වස්තුව” ලෙස හඳුන්වමු. Lock.night () කැඳවීමට පෙර, වත්මන් නූල් අගුළු වස්තුව මත සමමුහුර්ත කළ යුතුය; wait () ඉන්පසු මෙම අගුල මුදා හරින අතර අගුල හා සම්බන්ධ “පොරොත්තු ලේඛනයට” නූල් එක් කරයි. පසුව, තවත් නූලකට එකම අගුළු වස්තුව මත සමමුහුර්ත කර lock.notify () අමතන්න. මෙය මුල්, පොරොත්තු නූල් අවදි කරයි. මූලික වශයෙන්, රැඳී සිටින්න () / දැනුම් දීම () නින්ද () / බාධා කිරීම් () වැනි ය, ක්‍රියාකාරී නූල් වලට පමණක් නිදි නූල් වෙත සෘජු දර්ශකයක් අවශ්‍ය නොවේ, නමුත් හවුල් අගුළු වස්තුවට පමණි.

synchronized(LOCK) {   
   Thread.sleep(1000); // LOCK is held
}

synchronized(LOCK) {   
   LOCK.wait(); // LOCK is not held
}

ඉහත සියළු කරුණු වර්ගීකරණය කරමු:

Call on:

• රැඳී සිටින්න (): වස්තුවක් අමතන්න; වත්මන් නූල් අගුළු වස්තුව මත සමමුහුර්ත කළ යුතුය.
• නින්ද (): නූල් එකක් අමතන්න; සෑම විටම දැනට නූල් ක්‍රියාත්මක කරයි.

Synchronized:

• රැඳී සිටින්න (): සමමුහුර්ත කළ විට බහු නූල් එකම වස්තුව එකින් එක ප්‍රවේශ වේ.
• නින්ද (): සමමුහුර්ත කළ විට බහු නූල් නිදි නූල් නිදා ගැනීමට බලා සිටී.

Hold lock:

• රැඳී සිටින්න (): වෙනත් වස්තූන් ක්‍රියාත්මක කිරීමට අවස්ථාව ලබා ගැනීම සඳහා අගුල මුදා හරින්න.
• නින්ද (): කාලය ඉකුත්වී ඇත්නම් හෝ යමෙකු බාධා කරන්නේ නම් අවම වශයෙන් වාර ගණනක්වත් අගුලු දමා තබන්න.

Wake-up condition:

• රැඳී සිටින්න (): ඇමතුම දැනුම් දෙන තුරු (), වස්තුවෙන් දැනුම් දෙන්න
• නින්ද (): අවම වශයෙන් කාලය ඉකුත්වන තුරු හෝ බාධා කිරීම් අමතන්න ().

Usage:

• නින්ද (): කාල සමමුහුර්තකරණය සඳහා සහ;
• රැඳී සිටින්න (): බහු-නූල්-සමමුහුර්තකරණය සඳහා.

Ref: වෙනස sleepසහwait

සරල වචන වලින් කිවහොත්, රැඳී සිටින්න වෙනත් නූලක් ඔබට ආයාචනා කරන තෙක් නින්ද යම් නිශ්චිත කාලයක් සඳහා “ඊළඟ ප්‍රකාශය ක්‍රියාත්මක නොකරන්න”.

තව දුරටත් නින්ද යනු නූල් පන්තියේ ස්ථිතික ක්‍රමයක් වන අතර එය ක්‍රියාත්මක වන්නේ නූල් මත වන අතර රැඳී සිටීම () වස්තු පන්තියේ පවතින අතර වස්තුවක් කැඳවනු ලැබේ.

තවත් කරුණක් නම්, ඔබ යම් වස්තුවක් මත රැඳී සිටින්නැයි ඇමතූ විට, සම්බන්ධ වූ නූල් වස්තුව සමමුහුර්ත කර පසුව බලා සිටී. :)

waitසහ sleepක්‍රම බෙහෙවින් වෙනස් ය:

• sleep "අවදි වීමට" ක්‍රමයක් නැත,
• එනමුත් waitපොරොත්තු කාලය තුළ “අවදි වීමේ” ක්‍රමයක් ඇත, වෙනත් නූල් ඇමතුමකින් notifyහෝ notifyAll.

ඒ ගැන සිතා බලන්න, නම් ඒ සම්බන්ධයෙන් නම් අවුල් සහගත ය; කෙසේ වෙතත් sleepසම්මත නමක් වන අතර waitඑය වින් API හි WaitForSingleObjectහෝ සමාන WaitForMultipleObjectsවේ.

මෙම ලිපියෙන්: http://javaconceptoftheday.com/difference-between-night-and-sleep-methods-in-java/

රැඳී සිටින්න () ක්‍රමය.

1) රැඳී සිටීම () ක්‍රමය ලෙස හඳුන්වන නූල් මඟින් එය තබා ඇති අගුල මුදා හරිනු ලැබේ.

2) අනෙක් නූල් එකම අගුලේ දැනුම් දීම් () හෝ දැනුම් දීම් () ක්‍රම සියල්ලම ඇමතීමෙන් පසුව නූල් නැවත අගුල ලබා ගනී.

3) සමමුහුර්ත කොටුව තුළ රැඳී සිටින්න () ක්‍රමය කැඳවිය යුතුය.

4) රැඳී සිටීම () ක්‍රමය සෑම විටම වස්තු මත කැඳවනු ලැබේ.

5) දැනුම් දීමේ () හෝ දැනුම් දීමේ සියලු () ක්‍රම ඇමතීමෙන් පොරොත්තු නූල් වෙනත් නූල් මගින් අවදි කළ හැකිය.

6) වේට් () ක්‍රමය ඇමතීමට, නූල් වලට වස්තු අගුලක් තිබිය යුතුය.

නින්ද () ක්‍රමය

1) නින්ද () ක්‍රමය ලෙස හඳුන්වන නූල් එය තබා ඇති අගුල නිදහස් නොකරයි.

2) නින්ද () ක්‍රමය සමමුහුර්ත කොටුව තුළ හෝ ඉන් පිටත කැඳවිය හැකිය.

3) නින්ද () ක්‍රමය සෑම විටම නූල් මත හැඳින්වේ.

4) නිදි කෙඳි වෙනත් නූල් මගින් අවදි කළ නොහැක. එසේ කළහොත්, නූල් InterruptException විසි කරයි.

5) නින්ද () ක්‍රමය ඇමතීමට, නූල්වලට වස්තු අගුලක් තිබිය යුතු නොවේ.

මෙහි රැඳී සිටින්න () එය වෙනත් ත්‍රෙඩ් එකකින් දැනුම් දෙන තෙක් රැඳී සිටින නමුත් නින්ද () ට යම් කාලයක් ගතවනු ඇත..එවිට එය ස්වයංක්‍රීයව සූදානම් තත්වයට මාරු වේ ...

1. wait()Objectපන්තියේ ක්‍රමයකි . පන්තියේ
   sleep()ක්‍රමයකි Thread.

2. sleep()නූල් sleepx මිලි තත්පරයට තත්වයට යාමට ඉඩ දෙයි .
   නූලක් නින්දට යන විට it doesn’t release the lock.

3. wait()නූල් අගුල මුදා හැරීමට ඉඩ දෙයි goes to suspended state. එකම වස්තුවක් සඳහා ක්‍රමයක් හෝ ක්‍රමයක් කැඳවූ
   විට මෙම නූල සක්‍රීය වේ.notify()notifAll()

නින්ද / බාධා කිරීම් සහ බලා සිටීම / දැනුම් දීම අතර ඇති විය හැකි විශාල වෙනසක් එයයි

• ඉල්ලා interrupt()තුළ sleep()සෑම විටම ව්යතිරේකයක් (උදා: අවුලට InterruptedException ඇති ෙහයින්ද,)
• ඉල්ලා notify()තුළ wait()නැහැ.

අවශ්‍ය නොවන විට ව්‍යතිරේකයක් ජනනය කිරීම අකාර්යක්ෂම වේ. ඔබ එකිනෙකා සමඟ ඉහළ අනුපාතයකින් සන්නිවේදනය කරන නූල් තිබේ නම්, ඔබ නිතරම බාධා කිරීම් අමතන්නේ නම් එය බොහෝ ව්‍යතිරේකයන් ජනනය කරනු ඇත, එය CPU හි සම්පූර්ණ නාස්තියකි.

ඔබ නිවැරදියි - නින්ද () එම නූල “නින්දට” හේතු වන අතර CPU ක්‍රියා විරහිත වී වෙනත් නූල් (වෙනත් ආකාරයකින් සන්දර්භය මාරු කිරීම ලෙසද හැඳින්වේ) සැකසෙනු ඇත.

අප දෙදෙනාම සීපීයූ භාවිතා නොකරන විට එය භාවිතා කිරීමට ඉඩ දීම බුද්ධිමත් යැයි පෙනෙන්නට තිබුණද, ඇත්ත වශයෙන්ම සන්දර්භය මාරු කිරීම සඳහා පොදු කාර්යයක් ඇත - නින්ද කොපමණ කාලයක් තිබේද යන්න මත පදනම්ව, එය CPU චක්‍රවල වඩා මිල අධික විය හැකිය. නූල් මාරු කිරීමට වඩා ඔබේ නූල් එම්එස් කිහිපයක් සඳහා කිසිවක් නොකර සිටීමයි.

නින්ද සන්දර්භ මාරුවකට බල කරන බව සලකන්න.

එසේම - පොදුවේ සන්දර්භය මාරු කිරීම පාලනය කළ නොහැක - රැඳී සිටින්න මෙහෙයුම් කාලය තුළ (සහ වැඩි කාලයක් බලා සිටිනු ඇත) වෙනත් නූල් සැකසීමට තෝරා ගත හැකිය.

ක්රම විවිධ දේ සඳහා භාවිතා වේ.

Thread.sleep(5000);   // Wait until the time has passed.

Object.wait();        // Wait until some other thread tells me to wake up.

Thread.sleep (n) බාධා කළ හැකි නමුත් Object.night () වෙත දැනුම් දිය යුතුය. රැඳී සිටීමට උපරිම කාලය නියම කළ හැකිය: Object.wait(5000)එබැවින් එය භාවිතා waitකිරීමට හැකි වනු ඇත , එර්, sleepනමුත් එවිට ඔබට අගුල් සමඟ කරදර විය යුතුය.

මෙම ක්‍රම දෙකම නිදා සිටියදී / බලා සිටියදී cpu භාවිතා නොකරයි.

ක්‍රම ක්‍රියාත්මක කරනු ලබන්නේ ස්වදේශීය කේතය භාවිතා කර, සමාන ඉදිකිරීම් භාවිතා කරන නමුත් එකම ආකාරයකින් නොවේ.

ඔබ ගැනම සොයා බලන්න: ස්වදේශීය ක්‍රමවල ප්‍රභව කේතය තිබේද? ගොනුව /src/share/vm/prims/jvm.cppආරම්භක ස්ථානයයි ...

රැඳී සිටින්න () සහ නින්ද () වෙනස්කම්?

Thread.sleep () එහි වැඩ නිම වූ පසු එය සෑම කෙනෙකුටම අගුල මුදා හැරීම පමණි. එය කිසි විටෙකත් කිසිවෙකුට අගුල මුදා නොහරින තුරු.

  Sleep() take the key, its never release the key to anyone, when its work completed then only its release then only take the key waiting stage threads.

Object.night () එය පොරොත්තු අවධියට යන විට, එය යතුර මුදා හරිනු ඇති අතර පරාමිතිය මත පදනම්ව තත්පර කිහිපයක් බලා සිටියි.

උදාහරණයක් වශයෙන්:

ඔබ කෝපි ඔබේ දකුණු අතේ ගන්නවා, ඔබට එකම අතේ තවත් අයෙකු රැගෙන යා හැකිය, ඔබ පහතට දමන්නේ කවදාද? තවද. මෙය නින්දයි () ඔබ නිදාගත් වේලාව ඔබ කිසිදු වැඩක් නොකළේය, ඔබ කරන්නේ නිදාගැනීම පමණි .. මෙහි ද එසේමය.

රැඳී සිටින්න (). ඔබ පහත් කොට තවත් එකක් ගත් විට ඔබ බලා සිටින විට එයින් අදහස් වන්නේ එයයි

ඔබ එකවර චිත්‍රපට එකකට වඩා වැඩියෙන් වාදනය කළ නොහැකි ක්‍රීඩකයෙකු මෙන් ඔබේ චිත්‍රපටයේ හෝ වෙනත් ඕනෑම දෙයක් වාදනය කරයි, එය මෙහි ඇත, ඔබ වසා දමා වෙනත් ඕනෑම චිත්‍රපටයක් හෝ ගීතයක් තෝරා ගන්නා විට රැඳී සිටින්න

waitඅගුල මුදා හරින අතර sleepඑසේ නොවේ. පොරොත්තු තත්වයේ ඇති නූල් එකක් කැඳවූ වහාම notifyහෝ අවදි වීමට සුදුසුකම් ලබයි notifyAll. නමුත් sleepනූල් වල අගුල තබා ඇති අතර එය සුදුසුකම් ලබන්නේ නින්දේ කාලය අවසන් වූ පසුව පමණි.

sleep()ක්‍රමය මඟින් වත්මන් නූල් නිශ්චිත කාලයක් සඳහා ධාවන තත්වයේ සිට අවහිර තත්වයට ගෙන යයි. වත්මන් නූල්වල කිසියම් වස්තුවක අගුලක් තිබේ නම් එය දිගටම රඳවා තබා ගනී, එයින් අදහස් වන්නේ වෙනත් නූල් වලට එම පන්ති වස්තුව තුළ සමමුහුර්ත ක්‍රමයක් ක්‍රියාත්මක කළ නොහැකි බවයි.

wait() ක්‍රමවේදය මඟින් වත්මන් නූල් නිශ්චිත කාලයකට හෝ දැනුම් දෙන තෙක් අවහිර තත්වයට පත්වේ, නමුත් මේ අවස්ථාවේ දී නූල් මඟින් වස්තුවේ අගුල මුදා හරිනු ලැබේ (එයින් අදහස් කරන්නේ වෙනත් නූල් වලට ඇමතුම් වස්තුවෙහි ඕනෑම සමමුහුර්ත ක්‍රමයක් ක්‍රියාත්මක කළ හැකි බවයි.

මගේ මතය අනුව, යාන්ත්‍රණ දෙකම අතර ඇති ප්‍රධාන වෙනස වන්නේ නූල් හැසිරවීමේ මූලිකම ක්‍රමය නින්ද / බාධා කිරීමයි. එනමුත් රැඳී සිටීම / දැනුම් දීම යනු නූල් අන්තර් සන්නිවේදනය පහසු කිරීම අරමුණු කරගත් සාරාංශයකි. මෙයින් අදහස් කරන්නේ නින්දට / බාධා කිරීමට ඕනෑම දෙයක් කළ හැකි නමුත් මෙම නිශ්චිත කාර්යය කිරීමට අපහසු බවයි.

රැඳී සිටීම / දැනුම් දීම වඩාත් සුදුසු වන්නේ ඇයි? පෞද්ගලික කරුණු කිහිපයක් මෙන්න:

1. එය මධ්‍යගත කිරීම බලාත්මක කරයි. තනි හවුල් වස්තුවක් සමඟ නූල් සමූහයක් අතර සන්නිවේදනය සම්බන්ධීකරණය කිරීමට එය ඉඩ දෙයි. මෙය කාර්යය බොහෝ සරල කරයි.

2. එය සමමුහුර්තකරණය බලාත්මක කරයි. එය සමමුහුර්ත කොටුවක රැඳී සිටීමට / දැනුම් දීමට ක්‍රමලේඛකයා ඇමතුම ඔතා තබන බැවිනි.

3. එය නූල් සම්භවය සහ අංකයෙන් ස්වාධීන වේ. මෙම ප්‍රවේශය සමඟ ඔබට අනෙක් නූල් සංස්කරණය නොකර හෝ පවතින ඒවා පිළිබඳ වාර්තාවක් තබා නොගෙන අත්තනෝමතික ලෙස තවත් නූල් එකතු කළ හැකිය. ඔබ නින්ද / බාධා කිරීම් භාවිතා කළේ නම්, පළමුව ඔබට නිදි කෙඳි වෙත යොමු කිරීම් තබා ගත යුතු අතර පසුව ඒවා එකින් එක බාධා කරන්න.

මෙය පැහැදිලි කිරීමට හොඳ ජීවිතයක් සඳහා උදාහරණයක් සම්භාව්‍ය අවන්හලක් වන අතර ඔවුන් අතර සන්නිවේදනය සඳහා පිරිස් භාවිතා කරන ක්‍රමවේදය වේටර්වරු පාරිභෝගික ඉල්ලීම් කේන්ද්‍රීය ස්ථානයක තබයි (කෝක් බෝඩ්, මේසයක් ආදිය), සීනුව නාද කරන්න, මුළුතැන්ගෙයි කම්කරුවෝ එවැනි ඉල්ලීම් කිරීමට පැමිණෙති. කිසියම් පා course මාලාවක් සුදානම් වූ පසු, මුළුතැන්ගෙයි සේවකයින් නැවත සීනුව නාද කරන අතර එමඟින් වේටර්වරුන් දැනුවත් වී ගනුදෙනුකරුවන් වෙත ගෙන යනු ඇත.

නින්ද පිළිබඳ උදාහරණය අගුල මුදා නොහරින අතර රැඳී සිටියි

මෙන්න පන්ති දෙකක් තිබේ:

1. ප්රධාන : ප්රධාන ක්රමය සහ නූල් දෙකක් අඩංගු වේ.

2. සිංගල්ටන් : මෙය ස්ථිතික ක්‍රම දෙකක් සහිත getInstance () සහ getInstance (බූලියන් isWait) සහිත තනි පන්තියකි.

   public class Main {
   
   private static Singleton singletonA = null;
   private static Singleton singletonB = null;
   
   public static void main(String[] args) throws InterruptedException {
   
   Thread threadA = new Thread() {
       @Override
       public void run() {
   
           singletonA = Singleton.getInstance(true);
   
       }
   };
   
   Thread threadB = new Thread() {
       @Override
       public void run() {
           singletonB = Singleton.getInstance();
   
           while (singletonA == null) {
               System.out.println("SingletonA still null");
           }
   
           if (singletonA == singletonB) {
               System.out.println("Both singleton are same");
           } else {
               System.out.println("Both singleton are not same");
           }
   
       }
   };
   
   threadA.start();
   threadB.start();
   
    }
   }

සහ

public class Singleton {

    private static Singleton _instance;

    public static Singleton getInstance() {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null)
                _instance = new Singleton();
        }
    }
    return _instance;

}

public static Singleton getInstance(boolean isWait) {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null) {
                if (isWait) {
                    try {
                        // Singleton.class.wait(500);//Using wait
                        Thread.sleep(500);// Using Sleep
                        System.out.println("_instance :"
                                + String.valueOf(_instance));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                _instance = new Singleton();
            }
        }
    }
    return _instance;

 }
}

දැන් මෙම උදාහරණය ක්‍රියාත්මක කිරීමෙන් ඔබට ප්‍රතිදානය පහළින් ලැබෙනු ඇත:

_instance :null
Both singleton are same

මෙහි threadA සහ threadB විසින් නිර්මාණය කරන ලද සිංගල්ටන් අවස්ථා සමාන වේ. එහි අර්ථය වන්නේ නූල් මුදා හැරෙන තුරු නූල් බී පිටත රැඳී සිටින බවයි.

දැන් Thread.sleep (500) අදහස් දක්වමින් Singleton.java වෙනස් කරන්න; සිංගල්ටන් ක්ලස්.වයිට් (500); . මෙහි සිංගල්ටන් ක්ලාස්.වයිට් (500) නිසා; method threadA විසින් සියළුම අත්පත් කර ගත් අගුල් සහ “ධාවනය කළ නොහැකි” තත්වයට ගෙන යනු ඇත, threadB සමමුහුර්ත කොටසට ඇතුළු වීමට වෙනසක් ලබා ගනී.

දැන් නැවත ධාවනය කරන්න:

SingletonA still null
SingletonA still null
SingletonA still null
_instance :com.omt.sleepwait.Singleton@10c042ab
SingletonA still null
SingletonA still null
SingletonA still null
Both singleton are not same

නූල් ඒ හා නූල් බී විසින් නිර්මාණය කරන ලද සිංගල්ටන් නිදර්ශන සමාන නොවේ. ඒ නිසා නූල් බී සමමුහුර්ත කොටසට ඇතුළු වීමට වෙනසක් ඇති අතර මිලි තත්පර 500 කට පසු නූල්ඒ එහි අවසාන ස්ථානයෙන් ආරම්භ වී තවත් එක් සිංගල්ටන් වස්තුවක් නිර්මාණය කළේය.

සමමුහුර්ත කොටසේ සිට කැඳවිය යුතුය: wait() ක්‍රමය සැමවිටම සමමුහුර්ත බ්ලොක් වලින් හැඳින්වේ, එනම් wait()ක්‍රමයට එය හැඳින්වීමට පෙර වස්තුව මොනිටරය අගුළු දැමිය යුතුය. නමුත් sleep()ක්‍රමයෙන් පිටත සමමුහුර්ත බ්ලොක් වලින් ඇමතිය හැකිය, එනම් sleep()ක්‍රමයට කිසිදු වස්තු මොනිටරයක් ​​අවශ්‍ය නොවේ.

IllegalMonitorStateException: නම් wait()ක්රමය වස්තුව අගුලු අත්පත් තොරව වඩා හැඳින්වේ IllegalMonitorStateExceptionක්රියාත්මක වීමේදී එහි දමනු ඇත, නමුත් sleep()ක්රමය වැනි හැර අවුලට නැහැ.

කුමන පන්තියට අයත්ද: wait() ක්‍රමය java.lang.Objectපන්තියට sleep()අයත් නමුත් ක්‍රමය java.lang.Threadපන්තියට අයත් වේ .

වස්තුව හෝ නූල් wait() මත කැඳවනු ලැබේ : ක්‍රමය වස්තූන් මත කැඳවනු ලබන නමුත් sleep()ක්‍රමය හැඳින්වෙන්නේ වස්තු නොව නූල් මත ය.

නූල් තත්වය:wait() වස්තුව මත ක්‍රමය කැඳවූ විට , වස්තුවේ මොනිටරය රඳවා ගත් නූල් ධාවනය සිට පොරොත්තු තත්වයට යන අතර නැවත ධාවනය කළ හැකි තත්වයට පැමිණිය හැක්කේ එම වස්තුව මත notify()හෝ notifyAll()ක්‍රමයක් කැඳවූ විට පමණි . පසුව නූල් උපලේඛන උපලේඛන මඟින් ධාවනය කළ හැකි සිට ධාවනය වන තත්වයට යා යුතුය. sleep()නූල් මත කැඳවූ විට එය දිවීමේ සිට පොරොත්තු තත්වයට යන අතර නින්දේ වේලාව අවසන් වූ විට නැවත ධාවනය කළ හැකි තත්වයට පැමිණිය හැකිය.

සමමුහුර්ත වාරණ සිට හමු වූ අවස්ථාවේ: විට wait()ක්රමය ලෙස හැඳින්වේ නූල් වස්තුව අගුලු පිටත් වේ. නමුත් sleep()සමමුහුර්ත කොටසේ හෝ ක්‍රමයේ නූල් වලින් ඇමතූ විට ක්‍රමය වස්තු අගුලෙන් ඉවත් නොවේ.

තවත් සඳහා විමර්ශන

ඔරකල් ප්රලේඛනය පිටුව සිට රැක () ක්රමය Object:

public final void wait()

1. මෙම වස්තුව සඳහා වෙනත් නූලක් notify()ක්‍රමයට හෝ ක්‍රමයට ආයාචනා කරන තෙක් වත්මන් නූල් රැඳී සිටීමට හේතු notifyAll()වේ. වෙනත් වචන වලින් කිවහොත්, මෙම ක්‍රමය හරියටම ඇමතුම ඉටු කරන ආකාරයට හැසිරේ wait(0).
2. වත්මන් නූල් මෙම වස්තුවේ මොනිටරය සතු විය යුතුය. නූල් මඟින් මෙම මොනිටරයේ හිමිකාරිත්වය මුදා හරින අතර තවත් නූලක් මෙම වස්තුවේ මොනිටරයේ රැඳී සිටින බව දැනුම් දෙන තෙක් බලා සිටී
3. බාධා කිරීම් සහ ව්‍යාජ අවදි කිරීම් සිදුවිය හැකිය
4. මෙම ක්‍රමය හැඳින්විය යුත්තේ මෙම වස්තුවේ මොනිටරයේ හිමිකරු වන නූල් වලින් පමණි

මෙම ක්රමය විසි කරයි

1. IllegalMonitorStateException - වත්මන් නූල් වස්තුවේ මොනිටරයේ හිමිකරු නොවේ නම්.

2. InterruptedException- වත්මන් නූල් දැනුම් දීමක් බලාපොරොත්තුවෙන් සිටියදී හෝ ඊට පෙර කිසියම් නූල් වත්මන් නූල් වලට බාධා කළහොත්. මෙම ව්‍යතිරේකය විසි කරන විට වත්මන් නූල් වල බාධාකාරී තත්ත්වය ඉවත් වේ.

පංතියේ නින්ද () ක්‍රමය පිළිබඳ ඔරකල් ප්‍රලේඛන පිටුවෙන් Thread:

public static void sleep(long millis)

1. පද්ධති කාලරාමු සහ උපලේඛනවල නිරවද්‍යතාව සහ නිරවද්‍යතාවයට යටත්ව, දැනට ක්‍රියාත්මක වන නූල් නිශ්චිත මිලි තත්පර ගණන සඳහා (තාවකාලිකව ක්‍රියාත්මක කිරීම නවත්වයි).
2. නූල් කිසිදු මොනිටරයක හිමිකාරිත්වය නැති නොකරයි.

මෙම ක්‍රමය විසි කරයි:

1. IllegalArgumentException - මිලි වල අගය .ණ නම්

2. InterruptedException- කිසියම් නූල් වත්මන් නූල් වලට බාධා කර ඇත්නම්. මෙම ව්‍යතිරේකය විසි කරන විට වත්මන් නූල් වල බාධාකාරී තත්ත්වය ඉවත් වේ.

වෙනත් ප්‍රධාන වෙනස:

wait()යනු ස්ථිතික ක්‍රමය sleep()(පන්ති ක්‍රමය) මෙන් නොව ස්ථිතික නොවන ක්‍රමයකි (නිදර්ශන ක්‍රමය).

wait()පවසන අන්දමට සමමුහුර්ත ක්රමය තුළ ලබා දෙන sleep()නිසා නොවන සමමුහුර්ත ක්රමය තුළ ලබා දෙන wait()ක්රමය වස්තුව මත අගුල විවෘත නමුත් sleep()හෝ yield()මෙම නිදහස් කරන්නේ lock().

• මෙම ක්‍රමය wait(1000)මඟින් වර්තමාන නූල් එක තත්පරයක් දක්වා නිදා ගැනීමට හේතු වේ .
  • නූල් එකකට notify()හෝnotifyAll() ක්‍රමවේදය ඇමතුමක් ලැබුණහොත් තත්පර 1 කට වඩා අඩු කාලයක් නිදා ගත හැකිය .
• ඇමතුම sleep(1000)වත්මන් නූල් හරියටම තත්පර 1 ක් නිදා ගැනීමට හේතු වේ .
  • ද නූල් නිදා ඕනෑම සම්පතක් ලොක් පැවැත්වීමට නැත . නමුත් පොරොත්තු නූලක් එසේ කරයි.

ඇත්ත වශයෙන්ම, මේ සියල්ල ජාවා ලේඛනයේ පැහැදිලිව විස්තර කර ඇත (නමුත් මම මෙය තේරුම් ගත්තේ පිළිතුරු කියවීමෙන් පසුව පමණි).

http://docs.oracle.com/javase/8/docs/api/index.html :

wait () - වත්මන් නූල් මෙම වස්තුවේ මොනිටරය සතු විය යුතුය. නූල් මඟින් මෙම මොනිටරයේ හිමිකාරිත්වය මුදා හරින අතර තවත් නූල් මඟින් මෙම වස්තුවේ මොනිටරයේ රැඳී සිටින බව දැනුම් දෙන තෙක් බලා සිටිනු ඇත. නූල් පසුව මොනිටරයේ හිමිකාරිත්වය නැවත ලබා ගත හැකි වන තෙක් බලා සිට නැවත ක්‍රියාත්මක කිරීම ආරම්භ කරයි.

නින්ද () - පද්ධති කාලරාමු සහ උපලේඛනවල නිරවද්‍යතාව සහ නිරවද්‍යතාවයට යටත්ව, දැනට ක්‍රියාත්මක වන නූල් නිශ්චිත මිලි තත්පර ගණන සඳහා තාවකාලිකව ක්‍රියාත්මක කිරීම නවත්වයි. නූල් කිසිදු මොනිටරයක හිමිකාරිත්වය නැති නොකරයි.