الفرق بين الانتظار() والنوم()

Question

ما هو الفرق بين wait() و sleep() في المواضيع ؟

هو فهم أن wait()-ing الموضوع لا يزال في تشغيل وضع ويستخدم دورات وحدة المعالجة المركزية ولكن sleep()-ing لا تستهلك أي دورات وحدة المعالجة المركزية الصحيح ؟

لماذا علينا سواء wait() و sleep():كيف تنفيذها تختلف في انخفاض مستوى ؟

Answer 1

A 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(); }
}

Answer 2

واحد الفرق الرئيسي لم تذكر حتى الان هو أنه في حين أن النوم على الموضوع لا <م> لا الافراج عن أقفال انها تحمل، في انتظار إطلاق القفل على الكائن الذي wait() ودعا.

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


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

Answer 3

وجدت هذا المنصب مفيدا.فإنه يضع الفرق بين Thread.sleep(), Thread.yield(), ، Object.wait() من الناحية الإنسانية.اقتباس:

كل ذلك في نهاية المطاف يجعل طريقها وصولا إلى نظام التشغيل المجدول ، أيدي timeslices إلى العمليات والخيوط.

sleep(n) يقول "لقد إنتهيت من timeslice و رجاء لا تعطيني واحد آخر على الأقل n ميلي ثانية." نظام التشغيل لا تحاول حتى جدول النوم الخيط حتى طلبت من الوقت قد انقضى.

yield() يقول "لقد إنتهيت من timeslice ، ولكن ما زال لدي عمل القيام به." نظام التشغيل هو حر في أن تعطي على الفور موضوع آخر timeslice, أو إعطاء بعض الصفحات الأخرى أو عملية المعالجة المركزية استسلام الموضوع أعطى للتو.

wait() يقول "لقد إنتهيت من timeslice.لا تعطيني آخر timeslice حتى يقوم شخص ما يدعو يخطر()." كما هو الحال مع sleep(), فإن نظام التشغيل لن حتى محاولة جدولة المهمة الخاصة بك إلا إذا كان شخص ما يدعو notify() (أو واحد من بضع الأخرى التنبيه سيناريوهات يحدث).

المواضيع أيضا تفقد ما تبقى من timeslice عندما يؤدون حجب IO وتحت بعض الظروف الأخرى.إذا كان مؤشر ترابط يعمل خلال كامل timeslice ، OS قسرا يأخذ السيطرة تقريبا إذا yield() كان قد دعا ، حيث أن عمليات أخرى يمكن تشغيل.

نادرا ما تحتاج yield(), ولكن إذا كان لديك حساب مع التطبيقات الثقيلة المنطقية المهمة الحدود إدخال yield() قد تحسين نظام الاستجابة (على حساب الوقت — تبديل السياق حتى مجرد إلى نظام التشغيل مرة أخرى ، ليست مجانية).قياس واختبار ضد الأهداف التي يهتمون دائما.

Answer 4

وهناك الكثير من الإجابات هنا ولكن لم أتمكن من العثور على التمييز الدلالي المذكورة على أي.

وانها ليست حول موضوع ذاته؛ كلتا الطريقتين مطلوبة لأنها تدعم مختلف جدا استخدام الحالات.

وsleep() يرسل الموضوع إلى النوم كما كان من قبل، انها مجرد حزم سياق ويتوقف تنفيذ لفترة محددة سلفا. وذلك من أجل ايقاظ عنه قبل الموعد المحدد، تحتاج إلى معرفة المرجع الموضوع. هذه ليست حالة شائعة في بيئة متعددة الخيوط. انها تستخدم في الغالب لوقت التزامن (على سبيل المثال أعقاب بالضبط 3.5 ثانية) و / أو الإنصاف الثابت تلوينها (النوم فقط لبعض الوقت وتدع الآخرين المواضيع العمل).

وwait()، على العكس من ذلك، هو آلية تزامن موضوع (أو الرسالة) التي تسمح لك لإعلام الموضوع الذي لديك أي إشارة المخزنة (ولا الرعاية). يمكنك التفكير في الأمر على النحو نشر الإشتراك نمط (wait == الاشتراك وnotify() == نشر). في الأساس باستخدام إعلام () تقوم بإرسال الرسالة (التي قد تكون وردت حتى لا على الإطلاق، وعادة كنت لا تهتم).

لتلخيص، وعادة ما تستخدم sleep() لوقت syncronization وwait() للمتعددة موضوع التزامن.

وأنها يمكن تنفيذها بنفس الطريقة في نظام التشغيل الأساسي، أو لا على الاطلاق (كما كان الإصدارات السابقة من جاوة أي خاصية تعدد حقيقي، وربما بعض نظام رصد السفن صغيرة لا تفعل ذلك أيضا). لا ننسى تدير جافا على VM، لذلك سيتم تحويل الشفرة في شيء مختلف وفقا لVM / OS / HW تشغيله على.

Answer 5

هنا سرد بعض الاختلافات الهامة بين 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    
}

Answer 6

هناك بعض الفرق الملاحظات الرئيسية أختتم بعد أن عمل على الانتظار النوم أولا نلقي نظرة على عينة باستخدام الانتظار() والنوم():

Example1:باستخدام انتظر() ، النوم():

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. اتصل على:
   • انتظر():ندعو الحالي الخيط الذي عقد HandObject كائن
   • النوم():اتصل على موضوع تنفيذ مهمة الحصول على البيرة (هو أسلوب فئة بحيث تؤثر على التوالي الحالية موضوع)
2. متزامنة:
   • انتظر():عندما متزامنة متعددة الخيط الوصول إلى نفس الكائن (HandObject) (عند الحاجة للاتصال بين أكثر من موضوع واحد (موضوع تنفيذ الترميز, موضوع تنفيذ الحصول على البيرة) الحصول على نفس الكائن HandObject )
   • النوم():عند الانتظار في حالة مواصلة تنفيذ (في انتظار البيرة المتاحة)
3. عقد قفل:
   • انتظر():الافراج عن قفل كائن آخر فرصة لتنفيذ (HandObject مجانا, يمكنك أن تفعل وظيفة أخرى)
   • النوم():تبقى قفل على الأقل t مرات (أو حتى يقطع) (عملي لا تزال لا ينتهي ، أنا مواصلة عقد قفل و انتظار بعض الشروط لمواصلة)
4. إيقاظ حالة:
   • انتظر():حتى اتصل يخطر(), notifyAll() من وجوه
   • النوم():على الأقل حتى الوقت تنتهي أو الاتصال يقطع
5. و النقطة الأخيرة هي عند استخدام كما estani تشير إلى:

يمكنك عادة استخدام النوم() الوقت-مزامنة والانتظار() ل الصفحات المتعددة-المزامنة.

يرجى تصحيح لي إذا كنت مخطئا.

Answer 7

الفرق بين الانتظار() والنوم()

• الفرق الأساسي هو أن wait() هو من Object و sleep() هو أسلوب ثابت من Thread.

• الفرق الرئيسي هو أن wait() تطلق قفل حين sleep() لا يعفي أي قفل في حين ينتظر.

• wait() يستخدم بين موضوع الاتصالات في حين sleep() يستخدم لإدخال وقفة على التنفيذ ، عموما.

• wait() ينبغي أن يسمى من داخل مزامنة أو آخر نحصل على IllegalMonitorStateException, في حين sleep() يمكن أن يسمى أي مكان.

• بدء تشغيل مؤشر ترابط جديد من wait(), عليك الاتصال notify() أو notifyAll().أما بالنسبة sleep(), الموضوع بدأ يحصل بعد فترة محددة من الزمن.

أوجه التشابه

• سواء جعل الترابط الحالي الذهاب إلى لا Runnable الدولة.
• كلاهما الأم الأساليب.

Answer 8

هذا هو سؤال بسيط جدا, لأن كل هذه أساليب مختلفة تماما استخدام.

الفرق الرئيسي هو أن تنتظر الإفراج عن القفل أو الشاشة أثناء النوم لا تفرج عن أي القفل أو الشاشة أثناء الانتظار.انتظر يستخدم بين موضوع الاتصالات أثناء النوم يستخدم لإدخال وقفة على التنفيذ.

هذا كان واضح و شرح الأساسية ، إذا كنت تريد أكثر من ذلك ثم مواصلة القراءة.

في حالة wait() طريقة الخيط يذهب في انتظار الدولة وأنه لن يعود تلقائيا حتى نسميه notify() طريقة (أو notifyAll() إذا كان لديك أكثر من موضوع واحد في انتظار الدولة تريد أن تستيقظ كل تلك الصفحات).وتحتاج متزامنة أو كائن قفل أو فئة قفل الوصول إلى wait() أو notify() أو notifyAll() الأساليب.وأكثر شيء واحد ، wait() يستخدم أسلوب بين موضوع البلاغ لأنه إذا كان الموضوع يدور في انتظار الدولة سوف تحتاج موضوع آخر إلى خدمة هذا الموضوع.

ولكن في حالة sleep() هذا هو الأسلوب الذي يستخدم لإجراء عملية بضع ثوان أو وقت تريد.لأنك لا تحتاج إلى أي استفزاز notify() أو notifyAll() طريقة للحصول على هذا الموضوع مرة أخرى.أو أنت لا تحتاج إلى أي موضوع آخر للاتصال مرة أخرى في هذا الموضوع.مثل إذا كنت تريد أن شيئا ما يجب أن يحدث بعد بضع ثوان في المباراة بعد المستخدم بدوره تريد المستخدم إلى الانتظار حتى الكمبيوتر يلعب ثم يمكنك ذكر sleep() الأسلوب.

وأحد أهم الفرق التي طلبت في كثير من الأحيان في المقابلات: sleep() ينتمي إلى Thread فئة wait() ينتمي إلى Object فئة.

كل هذه الاختلافات بين sleep() و wait().

و هناك تشابه بين كلا الأسلوبين:كلاهما يتم التحقق من البيان لذلك عليك محاولة للقبض أو يلقي للوصول إلى هذه الأساليب.

آمل أن يكون هذا سوف تساعدك.

Answer 9

المصدر : http://www.jguru.com/faq/view.jsp?EID=47127

Thread.sleep() يرسل الترابط الحالي في "لا Runnable" الدولة لبعض مقدار الوقت.موضوع تحافظ على شاشات وقد المكتسبة - أيإذا كان الموضوع هو حاليا في مزامنة كتلة أو طريقة أي موضوع آخر يمكن أن تدخل هذه الكتلة أو الأسلوب.إذا كان مؤشر ترابط آخر المكالمات t.interrupt() وسوف يستيقظ النائم الموضوع.

علما أن النوم هو أسلوب ثابت ، مما يعني أنه يؤثر دائما الترابط الحالي (واحد هو تنفيذ طريقة النوم).A خطأ شائع هو أن ندعو t.sleep() حيث t هو موضوع مختلف;حتى ذلك الحين, هو مؤشر الترابط الحالي الذي سوف ينام ، وليس ر الخيط.

t.suspend() هو إهمال.باستخدام فمن الممكن لوقف موضوع آخر من الترابط الحالي.تعليق الخيط تحافظ على جميع الشاشات ، وبما أن هذه الدولة ليست interruptable هو الجمود عرضة.

object.wait() يرسل الترابط الحالي في "لا Runnable" الدولة ، مثل sleep(), ولكن مع تطور.انتظر يطلق على كائن لا ترابط ؛ ونحن ندعو هذا الكائن "تأمين الكائن." قبل lock.wait() هو يسمى الترابط الحالي يجب مزامنة على قفل الكائن ؛ wait() ثم يطلق هذا القفل ، ويضيف الخيط إلى "قائمة الانتظار" المرتبطة القفل.في وقت لاحق, موضوع آخر يمكن مزامنة على نفس قفل موضوع الدعوة lock.notify().هذا يستيقظ الأصلي ، في انتظار الموضوع.أساسا ، wait()/notify() مثل sleep()/interrupt(), النشطة فقط الموضوع لا يحتاج مباشر مؤشر إلى النوم في الموضوع ، ولكن فقط إلى تأمين مشتركة الكائن.

Answer 10

انتظر والنوم هما شيئان مختلفان:

• في sleep() موضوع توقف عن العمل المحدد المدة.
• في wait() الموضوع يتوقف عن العمل حتى الكائن الذي انتظرت على إخطار عموما من المواضيع الأخرى.

Answer 11

وsleep هو وسيلة لThread، wait هو وسيلة لObject، لذلك wait/notify هو أسلوب من مزامنة البيانات المشتركة في جاوة (باستخدام <لأ href = "http://en.wikipedia.org/wiki/Monitor_٪28synchronization ٪ 29 "يختلط =" noreferrer "> رصد )، ولكن sleep هي طريقة بسيطة من موضوع إلى وقفة نفسها.

Answer 12

النوم() هو الأسلوب الذي يستخدم لإجراء عملية بضع ثوان أو وقت تريد ولكن في حالة الانتظار() طريقة الخيط يذهب في انتظار الدولة وأنه لن يعود تلقائيا حتى نسميه يخطر() أو notifyAll().

على فرق كبير هو أن انتظر() النشرات القفل أو الشاشة أثناء النوم() لا تطلق أي القفل أو الشاشة أثناء الانتظار.انتظر يستخدم بين موضوع الاتصالات أثناء النوم يستخدم لإدخال وقفة على التنفيذ ، عموما.

الخيط.النوم() يرسل الترابط الحالي في "لا Runnable" الدولة لبعض مقدار الوقت.موضوع تحافظ على شاشات اكتسب — أيإذا كان الموضوع هو حاليا في مزامنة كتلة أو طريقة أي موضوع آخر يمكن أن تدخل هذه الكتلة أو الأسلوب.إذا كان مؤشر ترابط آخر المكالمات t.يقطع() وسوف يستيقظ النائم الموضوع.علما أن النوم هو أسلوب ثابت ، مما يعني أنه يؤثر دائما الترابط الحالي (واحد هو تنفيذ طريقة النوم).وهناك خطأ شائع هو أن ندعو t.النوم() حيث t هو موضوع مختلف;حتى ذلك الحين, هو مؤشر الترابط الحالي الذي سوف ينام ، وليس ر الخيط.

الكائن.انتظر() يرسل الترابط الحالي في "لا Runnable" الدولة ، مثل النوم () ، ولكن مع تطور.انتظر يطلق على كائن لا موضوع.ونحن ندعو هذا الكائن "تأمين الكائن." قبل قفل.انتظر() يسمى الترابط الحالي يجب مزامنة على قفل الكائن ؛ انتظر() ثم يطلق هذا القفل ، ويضيف الخيط إلى "قائمة الانتظار" المرتبطة القفل.في وقت لاحق, موضوع آخر يمكن مزامنة على نفس قفل موضوع غلق المكالمة.إعلام().هذا يستيقظ الأصلي ، في انتظار الموضوع.في الأساس, انتظر()/إعلام() هو مثل النوم()/المقاطعة(), النشطة فقط الموضوع لا يحتاج مؤشر مباشرة إلى النوم في الموضوع ، ولكن فقط إلى تأمين مشتركة الكائن.

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

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

اسمحوا تصنيف جميع النقاط المذكورة أعلاه :

Call on:

• انتظر(): ندعو كائن ؛ الترابط الحالي يجب مزامنة على قفل الكائن.
• النوم(): اتصل على الموضوع;دائما حاليا تنفيذ الموضوع.

Synchronized:

• انتظر(): عندما متزامنة متعددة مؤشرات الترابط الوصول إلى نفس الكائن واحدا تلو الآخر.
• النوم(): عندما متزامنة متعددة المواضيع انتظر النوم على النائم الموضوع.

Hold lock:

• انتظر(): الافراج عن قفل الكائنات الأخرى أن يكون فرصة لتنفيذ.
• النوم(): تبقى قفل على الأقل t مرات إذا مهلة محددة أو شخص يقطع.

Wake-up condition:

• انتظر(): حتى اتصل يخطر(), notifyAll() من وجوه
• النوم(): على الأقل حتى الوقت تنتهي أو نداء المقاطعة().

Usage:

• النوم(): الوقت-التزامن ؛
• انتظر(): متعدد الصفحات-المزامنة.

Ref:مهرجان دبي السينمائي الدولي sleep و wait

Answer 13

wait و sleep أساليب مختلفة جدا:

• sleep لديه طريقة "الاستيقاظ" ،
• في حين wait طريقة "استيقاظ" خلال فترة الانتظار قبل مؤشر ترابط آخر يدعو notify أو notifyAll.

تعال إلى التفكير في الأمر ، أسماء مربكة في هذا الصدد ؛ ومع ذلك sleep هو معيار اسم wait مثل WaitForSingleObject أو WaitForMultipleObjects في Win API.

Answer 14

في كلمات بسيطة، الانتظار الانتظار حتى بعض الصفحات الأخرى استدعاء لك في حين النوم "لا أميل تنفيذ العبارة التالية" لفترة محددة من الزمن.

وأيضا فإن النوم هو أسلوب ثابت في الطبقة الموضوع وتعمل على موضوع، في حين انتظر () هو في الدرجة كائن ودعا كائن.

وثمة نقطة أخرى، عند استدعاء الانتظار على وجوه بعض، وموضوع المشاركة مزامنة الكائن ومن ثم ينتظر. :)

Answer 15

ومن هذا المنصب: http://javaconceptoftheday.com / الفرق بين-الانتظار والنوم وطرق في جافا /

الانتظار () طريقة.

1) الخيط الذي يدعو الانتظار () طريقة إصدارات قفل انها تحمل.

2) موضوع يستعيد القفل بعد المواضيع الأخرى يدعون إما إعلام () أو notifyAll () طرق على نفس القفل.

و3) الانتظار () يجب استدعاء الأسلوب داخل كتلة متزامنة.

و4) انتظر () ويسمى الأسلوب دائما على الكائنات.

ويمكن 5) يتم استيقظ المواضيع انتظار بنسبة المواضيع الأخرى التي تدعو إعلام () أو notifyAll () الأساليب.

و6) دعوة الانتظار () الأسلوب، يجب أن يكون موضوع قفل الكائن.

النوم () طريقة

1) الخيط الذي يدعو النوم طريقة () لا تحرير القفل انها تحمل.

2) النوم () يمكن استدعاء الأسلوب داخل أو خارج الكتلة متزامنة.

و3) النوم () ويسمى الأسلوب دائما على المواضيع.

و4) المواضيع النوم لا يمكن استيقظ من المواضيع الأخرى. إذا فعلت ذلك، سوف موضوع رمي InterruptedException.

و5) دعوة النوم () طريقة، وتحتاج موضوع ليس لديهم تأمين الكائن.

Answer 16

1. wait() طريقة Object فئة.
   sleep() طريقة Thread فئة.

2. sleep() يسمح للذهاب إلى الموضوع sleep الدولة x ميلي ثانية.
   عندما يكون الموضوع يذهب الى النوم it doesn’t release the lock.

3. wait() يسمح الخيط إلى الإفراج قفل goes to suspended state.
   هذا الموضوع سوف تكون نشطة عندما notify() أو notifAll() الطريقة ودعا إلى نفس الكائن.

Answer 17

واحد محتمل فرق كبير بين النوم/المقاطعة و الانتظار/إعلام أن

• الدعوة interrupt() خلال sleep() دائما يطرح استثناء (على سبيل المثال InterruptedException) ، في حين
• الدعوة notify() خلال wait() لا.

توليد استثناء عند عدم الحاجة إليها غير فعالة.إذا كان لديك خيوط التواصل مع بعضها البعض بمعدل مرتفع ، ثم سيكون توليد الكثير من الاستثناءات إذا كنت تدعو لمقاطعة كل وقت ، وهو مجموع النفايات من وحدة المعالجة المركزية.

Answer 18

وكنت على صواب - النوم () يسبب هذا الخيط إلى "النوم" وحدة المعالجة المركزية سوف تنفجر وعملية المواضيع الأخرى (والمعروف باسم تبديل السياق) فراس أعتقد انتظر يحافظ على وحدة المعالجة المركزية معالجة موضوع الحالي

.

ونحن على حد سواء لأنه على الرغم من أنه قد يبدو من المعقول السماح لأشخاص آخرين استخدام وحدة المعالجة المركزية في حين كنت لا تستخدم ذلك، actualy هناك النفقات العامة للسياق التحول - تبعا لمدى طويل من النوم ل، يمكن أن يكون أكثر تكلفة في دورات وحدة المعالجة المركزية للتبديل المواضيع مما هو عليه لمجرد أن الخيط الخاص بك لا تفعل شيئا لبضع مللي ثانية.

لاحظ أيضا أن النوم يجبر تبديل السياق.

وأيضا - بشكل عام فإنه من غير الممكن التحكم في تبديل السياق - خلال انتظر نظام التشغيل قد (وصية لفترات انتظار أطول) اختيار لمعالجة المواضيع الأخرى

.

Answer 19

وتستخدم أساليب لأشياء مختلفة.

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

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

وThread.sleep (ن) <م> يمكن تنقطع، ولكن Object.wait () يجب يتم إخطار <م>. فمن الممكن لتحديد الحد الأقصى لوقت الانتظار: Object.wait(5000) لذلك سيكون من الممكن استخدام wait ل، إيه، sleep ولكن بعد ذلك لديك لعناء مع أقفال

وأيا من الأساليب التي تستخدمها وحدة المعالجة المركزية أثناء النوم / الانتظار.

ويتم تطبيق أساليب استخدام التعليمات البرمجية الأصلية، وذلك باستخدام بنيات مماثلة ولكن ليس في نفس الطريق.

وابحث عن نفسك: هل شفرة المصدر من أساليب الأصلي المتاحة؟ و/src/share/vm/prims/jvm.cpp ملف هو نقطة الانطلاق ...

Answer 20

سوف

وهنا الانتظار () أن يكون في حالة انتظار حتى أنه إبلاغ عن طريق الموضوع آخر ولكن حيث والنوم () سوف يكون لها بعض time..after أنه سيتم نقل تلقائيا إلى الدولة جاهزة ...

Answer 21

وانتظر () والنوم () الاختلافات؟

و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.wait ()     عند الذهاب لمرحلة الانتظار، التي سوف يكون الافراج عن مفتاح والانتظار من أجل بعض الثواني استنادا إلى المعلمة.

لمثال:

وكنت تأخذ القهوة في يدكم اليد اليمنى، يمكنك أن تأخذ أي شخص آخر من نفس اليد، عندما وضع الخاص بك إلى أسفل ثم يستغرق سوى نفس نوع كائن آخر هنا. أيضا. هذا هو النوم ()  تنام الوقت الذي لم يكن أي عمل، تقومون به فقط ينام .. نفسه هنا أيضا.

والانتظار (). عندما كنت وضعت أسفل وأخذ بعضها البعض يعني بينما كنت في انتظار، وهذا الانتظار

وأنت فيلم اللعب أو أي شيء في النظام لك نفس اللاعب الذي لا يمكن أن تقوم به أكثر من واحد في حق الوقت، أن يكون لها هنا، عند إغلاق واختيار الفيلم أي شخص آخر أو أغنية يعني في حين يسمى الانتظار

Answer 22

وwait تطلق قفل وsleep لا. وموضوع في انتظار دولة مؤهلة للحصول على الاستيقاظ في أقرب وقت كما يطلق notify أو notifyAll. ولكن في حالة sleep الخيط يحافظ على قفل وأنه سوف يكون فقط مؤهلة مرة واحدة في وقت النوم قد انتهى.

Answer 23

وطريقة sleep() يتسبب في موضوع الحالي للانتقال من تشغيل الدولة لمنع الدولة لفترة زمنية محددة. إذا كان الترابط الحالي لديه خصلة من أي كائن فإنه يبقى عقده، وهو ما يعني أن المواضيع الأخرى لا يمكن تنفيذ أي طريقة متزامنة في هذا الكائن فئة.

وطريقة wait() يتسبب في موضوع الحالي للذهاب إلى دولة كتلة إما لفترة محددة أو حتى إعلام، ولكن في هذه الحالة موضوع النشرات القفل من وجوه (وهو ما يعني أن المواضيع الأخرى يمكن تنفيذ أية أساليب متزامنة من وجوه الدعوة .

Answer 24

في رأيي, الفرق الرئيسي بين كل الآليات التي من النوم/المقاطعة هو أبسط طريقة التعامل مع المواضيع ، بينما انتظر/إخطار هو فكرة مجردة تهدف إلى القيام ترابط بين التواصل أسهل. وهذا يعني أن النوم/المقاطعة يمكن أن تفعل أي شيء ، لكن هذه مهمة محددة هو من الصعب القيام به.

لماذا الانتظار/إبلاغ أكثر من مناسبة ؟ وهنا بعض الاعتبارات الشخصية:

1. وهو ما يفرض المركزية. فإنه يسمح تنسيق الاتصال بين مجموعة من المواضيع مع واحد مشترك الكائن.هذا يبسط العمل الكثير.

2. وهو ما يفرض التزامن. لأنه يجعل مبرمج التفاف الدعوة إلى الانتظار/يخطر في مزامنة كتلة.

3. انها مستقلة عن موضوع أصل الرقم. مع هذا النهج يمكنك إضافة المزيد من المواضيع بشكل تعسفي دون تحرير المواضيع الأخرى أو حفظ المسار من القائمة.إذا كنت تستخدم النوم/المقاطعة الأولى سوف تحتاج إلى الحفاظ على إشارات إلى النوم المواضيع ثم يقطع عليهم واحدا تلو الآخر ، من جهة.

مثال من واقع الحياة التي هي جيدة لشرح هذا هو كلاسيكي مطعم الأسلوب الذي الأفراد يستخدمونها للتواصل فيما بينها:النوادل ترك طلبات العملاء في مكان مركزي (لوحة الفلين ، طاولة ، الخ) ، يرن جرس والعمال من المطبخ حان لاتخاذ مثل هذه الطلبات.وبمجرد أن هناك أي استعداد بالطبع, المطبخ أفراد دق الجرس مرة أخرى بحيث النوادل علم ونقلهم إلى العملاء.

Answer 25

مثال عن النوم لا سراح قفل و لا انتظر

هنا وهناك فئتين :

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 هي نفسها.يعني threadB ينتظر خارج حتى threadA الإفراج عنها قفل.

الآن تغيير Singleton.java من خلال التعليق الموضوع.النوم(500);طريقة uncommenting المفرد.فئة.انتظر(500);.هنا من المفرد.فئة.انتظر(500);طريقة threadA سيتم الإفراج عن جميع اكتساب أقفال ينتقل إلى "عدم Runnable" الدولة 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

هنا المفرد الحالات التي تم إنشاؤها بواسطة threadA و threadB ليست نفسها بسبب threadB حصل تغيير للدخول في مزامنة كتلة بعد 500 ميلي ثانية threadA بدأت من هذا الموقف و خلق واحد أكثر الكائن المفرد.

Answer 26

ينبغي أن يسمى من مزامنة كتلة : wait() طريقة يسمى دائما من مزامنة أي كتلة wait() يحتاج طريقة قفل كائن مراقبة من قبل الكائن الذي يطلق عليه.ولكن sleep() الطريقة يمكن أن يسمى من خارج متزامنة كتلة أي sleep() الطريقة لا تحتاج إلى أي كائن مراقبة.

IllegalMonitorStateException : إذا wait() وتسمى طريقة دون الحصول على كائن قفل من IllegalMonitorStateException طرح في وقت التشغيل ، ولكن sleep() طريقة لا يلقي مثل هذا الاستثناء.

الذي ينتمي إلى الطبقة : wait() طريقة ينتمي إلى java.lang.Object الدرجة ولكن sleep() طريقة ينتمي إلى java.lang.Thread فئة.

ودعا كائن أو الموضوع : wait() الطريقة تسمى الأشياء ولكن sleep() الطريقة تسمى على المواضيع لا الأجسام.

موضوع الدولة : عندما wait() الطريقة تسمى على كائن مؤشر الترابط الذي حصلت الكائن رصد يذهب من الترشح في انتظار الدولة و يمكن العودة إلى runnable الدولة فقط عندما notify() أو notifyAll() طريقة ويطلق على هذا الكائن.و في وقت لاحق موضوع جدولة مواعيد هذا الموضوع أن تذهب من runnable إلى إدارة الدولة.عندما sleep() ويطلق على الموضوع يذهب من الترشح في انتظار الدولة و يمكن العودة إلى runnable الدولة من النوم عندما يحين الوقت.

عندما دعا من مزامنة كتلة : عندما wait() الطريقة تسمى الخيط يترك الكائن قفل.ولكن sleep() طريقة عندما دعا من مزامنة كتلة أو طريقة الخيط لا يترك الكائن قفل.

لمزيد من المرجعية

Answer 27

من صفحة وثائق oracle على انتظر() طريقة Object:

public final void wait()

1. أسباب الترابط الحالي الانتظار حتى آخر مؤشر ترابط استدعاء notify() أو أسلوب notifyAll() طريقة لهذا الكائن.وبعبارة أخرى, هذه الطريقة يتصرف بالضبط كما لو كانت ببساطة ينفذ الدعوة wait(0).
2. الترابط الحالي يجب أن تملك هذا الكائن مراقبة.موضوع النشرات ملكية هذه الشاشة و ينتظر حتى آخر خيط بإعلام المواضيع ينتظر هذا الكائن مراقبة الاستيقاظ
3. ام زائفة wakeups ممكنة
4. هذا الأسلوب يجب أن يكون فقط وهو الخيط الذي هو صاحب هذا الكائن رصد

هذا الأسلوب يلقي

1. IllegalMonitorStateException - إذا كان مؤشر الترابط الحالي ليس مالك الكائن مراقبة.

2. InterruptedException - إذا كان أي موضوع انقطاع التيار الموضوع قبل أو أثناء الترابط الحالي في انتظار إشعار.توقف حالة من الترابط الحالي يتم مسح عندما طرح استثناء.

من صفحة وثائق oracle على النوم() طريقة Thread الدرجة:

public static void sleep(long millis)

1. أسباب تنفذ حاليا موضوع النوم (مؤقتا وقف التنفيذ) لعدد محدد من ميلي ثانية ، رهنا ودقة من نظام توقيت والمنظمون.
2. موضوع لا يفقد ملكية أي من الشاشات.

هذا الأسلوب يلقي:

1. IllegalArgumentException - إذا كانت قيمة ميليس هو سلبي

2. InterruptedException - إذا كان أي موضوع قد توقف الترابط الحالي.توقف حالة من الترابط الحالي يتم مسح عندما طرح استثناء.

غيرها من الفرق الرئيسية:

wait() non-static method (على سبيل المثال طريقة) على عكس أسلوب ثابت sleep() (أسلوب فئة).

Answer 28

ويعطى wait() داخل طريقة متزامنة في حين يتم إعطاء sleep() داخل أسلوب غير متزامنة لطريقة wait() الافراج عن قفل على الكائن ولكن sleep() أو yield() يفعل الافراج عن lock().

Answer 29

والانتظار مع قيمة مهلة يمكن صحوة على قيمة المهلة انقضت أو يخطر أيهما أقرب (أو المقاطعة أيضا)، في حين، والنوم يستيقظ على قيمة المهلة انقضت أو يقطع أيهما أسبق. الانتظار () مع عدم وجود قيمة المهلة سوف ننتظر إلى الأبد حتى إشعار أو توقف

Answer 30

• طريقة wait(1000) أسباب الترابط الحالي إلى النوم يصل إلى ثانية واحدة.
  • موضوع يمكن أن النوم أقل من 1 في الثانية إذا كان يتلقى notify() أو notifyAll() استدعاء الأسلوب.
• الدعوة إلى sleep(1000) أسباب الترابط الحالي إلى النوم بالضبط 1 ثانية.
  • أيضا النوم الموضوع لا يحمل قفل أي مورد.ولكن في انتظار موضوع لا.