Wait () ve sleep () arasındaki fark

A wait()ve sleep()Threads arasındaki fark nedir ?

A wait()-ing İş Parçasının hala çalışma modunda olduğunu ve CPU döngülerini kullandığını, ancak a sleep()-ing'in herhangi bir CPU döngüsünü doğru tüketmediğini anlamış mıyım?

Neden her ikisine de sahibiz wait()ve sleep(): uygulamaları daha düşük düzeyde nasıl değişiyor?

A monitörde waitçağrılan başka bir iş parçacığı tarafından "uyandırılabilir" notifybeklenirken sleep, alamaz. Ayrıca , monitör nesnesindeki bir blokta bir wait(ve notify) gerçekleşmelidir , ancak şunları yapmaz:synchronizedsleep

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

Bu noktada şu anda yürütülen iş parçacığı monitörü bekler ve serbest bırakır . Başka bir iş parçacığı

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

(aynı monnesnede) ve ilk iş parçacığı (monitörde bekleyen tek iş parçacığı olduğu varsayılarak) uyanır.

notifyAllMonitörde birden fazla iş parçacığı bekliyorsa da arayabilirsiniz - bu hepsini uyandırır . Bununla birlikte, iş parçacıklarından sadece biri monitörü yakalayabilecek ( waitbir synchronizedblokta olduğunu hatırlayacaktır ) ve devam edebilir - diğerleri monitörün kilidini elde edene kadar bloke edilir.

Başka bir nokta aramak olmasıdır waitüzerine Objectkendisi aramak oysa (bir nesnenin monitörde bekleyin yani) sleepüzerineThread .

Henüz başka nokta alabilmenizdir sahte açılışları dan wait(nedensiz özgeçmişlerini bekliyor yani iplik). Her zamanwait aşağıdaki gibi bir koşulda dönerken :

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

Henüz belirtilmeyen bir temel fark olduğuna dair bir konuya uyku yok ederken değil nesne bu konuda serbest bırakır kilidi beklerken, bu tutar kilitlerininwait() üzerine denir.

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


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

Bu gönderiyi yararlı buldum . Bu arasındaki farkı koyar Thread.sleep(), Thread.yield()ve Object.wait()insani açıdan. Alıntılamak:

Sonunda, işletim sistemine ve iş parçacıklarına zaman dilimlerini dağıtan OS'nin zamanlayıcısına doğru yol alır.

sleep(n)diyor “Ben timeslice bitirdim, ve bana en az n milisaniye için bir tane daha etmeyiniz.” İşletim sistemi, istenen zaman geçene kadar uyku ipliğini zamanlamaya bile çalışmaz.

yield()“Zaman dilimimle işim bitti, ama hala yapacak işlerim var” diyor . İşletim sistemi, iş parçacığına hemen başka bir zaman dilimi vermek veya başka bir iş parçacığı vermek veya CPU'yu işlemek için serbest bırakılan iş parçacığından vazgeçmekte serbesttir.

wait()diyor benim timeslice işim bitti”. Birisi bildirim () çağrısı yapana kadar bana başka bir zaman dilimi verme. ” Olduğu gibi sleep(), işletim sistemi, biri aramadığı sürece notify()(veya birkaç uyandırma senaryosundan biri gerçekleşmedikçe) görevinizi zamanlamaya bile çalışmaz .

İplikler ayrıca, bloke edici IO gerçekleştirirken ve diğer birkaç koşulda zaman dilimlerinin geri kalanını da kaybeder. Bir iş parçacığı tüm zaman diliminde çalışırsa, işletim sistemi zorla kontrolü kabaca sankiyield() çağrılmış , böylece diğer işlemler çalışabilir.

Nadiren ihtiyacınız vardır yield(), ancak mantıksal görev sınırlarına sahip bir hesaplama-ağır uygulamanız varsa, sistem yanıt yield() verebilirliğini artırabilir (zaman pahasına - bağlam anahtarları, yalnızca işletim sistemine ve geri bile olsa, ücretsiz değildir). Önem verdiğiniz hedefleri her zaman olduğu gibi ölçün ve test edin.

Burada pek çok cevap var ama hiçbirinde bahsedilen anlambilimsel ayrımı bulamadım.

İpliğin kendisi ile ilgili değil; her iki yöntem de çok farklı kullanım durumlarını destekledikleri için gereklidir.

sleep()iş parçacığını daha önce olduğu gibi uyku moduna gönderir, yalnızca içeriği paketler ve önceden tanımlanmış bir süre için yürütmeyi durdurur. Bu nedenle, zamanından önce uyandırmak için, Konu referansını bilmeniz gerekir. Bu çok iş parçacıklı bir ortamda yaygın bir durum değildir. Çoğunlukla zaman senkronizasyonu (örn. Tam olarak 3,5 saniye içinde uyanma) ve / veya sabit kodlu dürüstlük (sadece bir süre uyuyun ve diğer ipliklerin çalışmasına izin verin) için kullanılır.

wait()aksine, saklanmış referansınız olmayan (ne de bakım) bir Konuyu bildirmenizi sağlayan bir evre (veya mesaj) senkronizasyon mekanizmasıdır. Bunu bir yayınla abone olma modeli olarak düşünebilirsiniz ( wait== abone olun venotify() == yayınlayın). Temel olarak notify () kullanarak bir mesaj gönderiyorsunuz (hiç alınmamış bile olabilir ve normalde umursamazsınız).

Özetlemek gerekirse, normalde sleep()zaman senkronizasyonu ve wait()çoklu evre senkronizasyonu için kullanılır.

Temel işletim sisteminde aynı şekilde uygulanabilir veya hiç uygulanamaz (Java'nın önceki sürümlerinde gerçek bir çoklu iş parçacığı olmadığından, muhtemelen bazı küçük VM'ler de bunu yapmaz). Java'nın bir VM'de çalıştığını unutmayın, bu nedenle kodunuz üzerinde çalıştığı VM / OS / HW'ye göre farklı bir şeye dönüştürülecektir.

Burada, yöntemler wait()ile sleep()yöntemler arasında birkaç önemli fark listeledim .
PS: Ayrıca kütüphane kodunu görmek için bağlantılara tıklayın (dahili çalışma, daha iyi anlamak için biraz oynayın).

Bekle()

1. wait() yöntem kilidi serbest bırakır.
2. wait() yöntemi Objectsınıf .
3. wait() statik olmayan yöntemdir - public final void wait() throws InterruptedException { //...}
4. wait()notify()veya notifyAll()yöntemlerle bildirilmelidir .

5. wait() yanlış alarmla başa çıkmak için bir döngüden yöntemin çağrılması gerekir.

6. wait() yöntem senkronize bağlamdan çağrılmalıdır (yani senkronize yöntem veya blok), aksi takdirde IllegalMonitorStateException

uyku()

1. sleep() yöntem kilidi serbest bırakmaz.
2. sleep() yöntemi java.lang.Threadsınıf .
3. sleep() statik yöntemdir - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. belirtilen süreden sonra, sleep() tamamlanır.
5. sleep()Döngüden çağırmamak daha iyidir (yani aşağıdaki koda bakınız ).
6. sleep()her yerden çağrılabilir. özel bir gereklilik yoktur.

Ref: Bekleme ve Uyku arasındaki fark

Arama bekletme ve uyku yöntemi için kod snippet'i

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

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

Bekleme ve uyku üzerinde çalıştıktan sonra tamamladığım bazı önemli anahtar notlar var, önce wait () ve sleep () kullanarak örneğe bir göz atın:

Örnek 1 : wait () ve sleep () kullanımı:

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

Bazı önemli notları açıklığa kavuşturalım:

1. Şu numarayı arayın :
   • wait (): HandObject Nesnesini tutan geçerli iş parçacığını çağır
   • sleep (): İş parçacığında çağrı görev alma bira olsun (sınıf yöntemi yani geçerli çalışan iş parçacığını etkiler)
2. Senkronize edildi :
   • wait (): senkronize çoklu iş parçacığı erişimine aynı Nesne (HandObject) (Birden fazla iş parçacığı (iş parçacığı yürütme kodlaması, iş parçacığı yürütme bira) erişimi) arasında aynı nesneye erişim gerektiğinde (HandObject)
   • sleep (): yürütmeye devam etmek için bekleme koşulu (Bira bekleniyor)
3. Kilit tutun :
   • wait (): diğer nesnelerin kilidini serbest bırakma, yürütme şansı var (HandObject ücretsiz, başka bir iş yapabilirsin)
   • uyku (): en az t kez (ya da kesilene kadar) kilitli tut
4. Uyandırma koşulu :
   • wait (): nesneden çağrı notify (), notifyAll ()
   • sleep (): en az süre sona erene veya arama kesmeye kadar
5. Ve son nokta, estani'nin belirttiği gibi kullanmaktır :

normalde zaman senkronizasyonu için sleep () ve çoklu evre senkronizasyonu için wait () kullanırsınız.

Yanılıyorsam lütfen beni düzeltin.

Wait () ve sleep () arasındaki fark

• Temel farklılık olduğunu wait()ila Objectve sleep()statik bir yöntemdir Thread.

• En büyük fark, wait()kilidi sleep()serbest bırakırken, beklerken herhangi bir kilidi serbest bırakmamasıdır.

• wait()sleep()genellikle yürütme sırasında bir duraklama sağlamak için kullanılırken, zincirler arası iletişim için kullanılır.

• wait()içeriden senkronize çağrılmalı yoksa başka bir şekilde elde IllegalMonitorStateExceptionedilirken sleep() , her yerde çağrılabilir.

• Bir ileti dizisini yeniden başlatmak için veya öğesini wait()aramanız gerekir . Gelince iplik belirli bir zaman aralığından sonra başlatılır.notify()notifyAll()sleep(),

benzerlikler

• Her ikisi de geçerli iş parçacığının Çalıştırılamaz durumuna geçmesini sağlar .
• Her ikisi de yerel yöntemlerdir.

Bu çok basit bir soru çünkü her iki yöntemin de tamamen farklı bir kullanımı var.

En büyük fark, uyku beklerken kilidi veya monitörü serbest bırakmazken kilidi veya monitörü serbest bırakmak için beklemektir. Bekleme iş parçacıkları arası iletişim için kullanılırken uyku yürütme sırasında duraklama sağlamak için kullanılır.

Bu sadece açık ve temel bir açıklama, eğer daha fazlasını istiyorsanız, okumaya devam edin.

Durumunda wait()yöntem iplik durumuna bekleyen gider ve biz arayana kadar otomatik geri gelmeyecek notify()yöntemi (veya notifyAll()siz bekleme durumu daha sonra bir iplik vardır ve ilgili dişin tüm uyanmak istiyorsanız). Ve senkronize veya nesne kilidi veya sınıf kilit erişimine gerek wait()ya notify()ya notifyAll()yöntemlerle. Ve bir şey daha,wait() yöntem, iş parçacıkları arası iletişim için kullanılır çünkü bir iş parçacığı bekleme durumuna girerse, o iş parçacığını uyandırmak için başka bir iş parçacığına ihtiyacınız olacaktır.

Ancak bu durumda sleep(), işlemi birkaç saniye veya istediğiniz süre boyunca tutmak için kullanılan bir yöntemdir. Çünkü o iş parçacığını geri almak için herhangi bir yöntemi notify()veya notifyAll()yöntemi kışkırtmanız gerekmez . Veya bu konuyu geri aramak için başka bir konuya ihtiyacınız yoktur. İsterseniz bir şey birkaç saniye sonra bir oyunda olduğu gibi kullanıcının dönüşünden sonra kullanıcının bilgisayar çalıncaya kadar beklemesini istersiniz.sleep() yöntemden .

Ve röportajlarda sık sık sorulur bir daha önemli farkı: sleep()ait Threadsınıf ve wait()aittirObject sınıfın.

Bunlar sleep()ve arasındaki farklarwait() .

Ve her iki yöntem arasında bir benzerlik vardır: her ikisi de kontrol edilen deyimdir, bu nedenle bu yöntemlere erişmek için catch veya throw'ı denemeniz gerekir.

Umarım bu sana yardımcı olmuştur.

kaynak: http://www.jguru.com/faq/view.jsp?EID=47127

Thread.sleep()geçerli iş parçacığını bir süre "Çalıştırılamaz" durumuna gönderir . İş parçacığı, izlediği monitörleri tutar - yani iş parçacığı şu anda senkronize bir blok veya yöntemdeyse, başka hiçbir iş parçacığı bu bloğa veya yönteme giremez. Başka bir iş parçacığı ararsat.interrupt() , uyku iş parçacığını uyandırır.

Uyku durumunun statik bir yöntem olduğunu, yani her zaman geçerli iş parçacığını (uyku yöntemini yürüten yöntemi) etkilediği anlamına gelir. Yaygın bir hata, t.sleep()t'nin farklı bir iş parçacığı olduğu yeri aramaktır; o zaman bile, t iplik değil, uyuyacak olan geçerli ipliktir.

t.suspend()kullanımdan kaldırıldı. Kullanarak mevcut iplik dışında bir ipliği durdurmak mümkündür. Askıya alınmış bir iplik tüm monitörlerini tutar ve bu durum kesintiye uğramadığından kilitlenmeye eğilimlidir.

object.wait()geçerli iş parçacığını "Çalıştırılamaz" durumuna (örneğin sleep(), bir bükülmeyle) gönderir . Bir iş parçacığında değil, bir nesnede bekleme çağrılır; bu nesneye "kilit nesnesi" diyoruz. Önceden lock.wait()çağrılmadan önce , geçerli iş parçacığı kilit nesnesinde eşitlenmelidir; wait() daha sonra bu kilidi serbest bırakır ve iş parçacığı kilit ile ilişkili "bekleme listesine" ekler. Daha sonra, başka bir iş parçacığı aynı kilit nesnesi ve çağrı üzerinde senkronize edilebilir lock.notify(). Bu, orijinal, bekleyen ipliği uyandırır. Temelde, wait()/ notify()gibi sleep()/ interrupt(), yalnızca etkin iplik ama sadece paylaşılan kilit nesneye, uyku iplik doğrudan işaretçi ihtiyacı yoktur.

Bekleme ve uyku iki farklı şeydir:

• İçinde sleep() parçacığında belirtilen süre boyunca çalışma durur.
• İş wait()parçacığında, bekleyen nesne, genellikle diğer iş parçacıkları tarafından bildirilene kadar çalışmayı durdurur.

sleepbir yöntemdir Thread, waitbir yöntemdir Object, bu yüzden wait/notify(kullanarak Java paylaşılan verileri eşzamanlı bir tekniktir monitör ), ancak sleepkendisi duraklama ipliğinin basit bir yöntemdir.

uyku() işlemi birkaç saniye veya istediğiniz süre boyunca tutmak için kullanılan bir yöntemdir ancak wait () yöntemi iş parçacığı bekleme durumuna girerse ve biz bildir () çağrılıncaya kadar otomatik olarak geri gelmez notifyAll ().

En büyük fark , wait () kilidinin veya monitörün serbest kalmasıdır, sleep () ise bekleme sırasında herhangi bir kilit veya monitörün serbest kalmamasıdır. Bekleme iş parçacıkları arası iletişim için kullanılırken, uyku genellikle yürütme sırasında duraklama sağlamak için kullanılır.

Thread.sleep () geçerli iş parçacığını bir süre “Çalıştırılamaz” durumuna gönderir. İş parçacığı, aldığı monitörleri tutar - yani iş parçacığı şu anda senkronize bir blok veya yöntemdeyse, başka hiçbir iş parçacığı bu bloğa veya yönteme giremez. Başka bir iş parçacığı t.interrupt () öğesini çağırırsa, uyku iş parçacığını uyandırır. Uyku durumunun statik bir yöntem olduğunu, yani her zaman geçerli iş parçacığını (uyku yöntemini yürüten yöntemi) etkilediği anlamına gelir. Yaygın bir hata t'nin farklı bir iş parçacığı olduğu t.sleep () işlevini çağırmaktır; o zaman bile, t iplik değil, uyuyacak olan geçerli ipliktir.

object.wait () geçerli iş parçacığını sleep () gibi ama bir bükülme ile “Çalıştırılamaz” durumuna gönderir. Bir iş parçacığında değil, bir nesnede bekleme çağrılır; bu nesneye “kilit nesnesi” diyoruz. Lock.wait () çağrılmadan önce, geçerli iş parçacığı kilit nesnesi üzerinde eşitlenmelidir; wait () daha sonra bu kilidi serbest bırakır ve parçacığı kilitle ilişkili “bekleme listesine” ekler. Daha sonra, başka bir evre aynı kilit nesnesinde senkronize edilebilir ve lock.notify () öğesini çağırabilir. Bu, orijinal, bekleyen ipliği uyandırır. Temel olarak, wait () / notify () işlevi sleep () / interrupt () gibidir, yalnızca etkin iş parçacığının uyku iş parçacığına doğrudan işaretçisi değil, yalnızca paylaşılan kilit nesnesine ihtiyacı vardır.

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

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

Yukarıdaki tüm noktaları kategorize edelim:

Call on:

• wait (): Bir nesneyi çağırın; geçerli iş parçacığı kilit nesnesinde eşitlenmelidir.
• sleep (): Bir Konuyu Çağırın; her zaman şu anda iş parçacığı yürütülüyor.

Synchronized:

• wait (): senkronize edilmiş birden çok iş parçacığı aynı Nesneye tek tek eriştiğinde.
• sleep (): senkronize edilmiş birden fazla iş parçacığı, uyku iş parçacığının üzerinde uyumayı bekler.

Hold lock:

• wait (): diğer nesnelerin yürütme şansı için kilidi serbest bırakın.
• sleep (): zaman aşımı belirtilirse veya biri kesilirse en az t kez kilitli tutun.

Wake-up condition:

• wait (): nesneyden notify () çağrılıncaya kadar notifyAll ()
• sleep (): en az süre sona erene veya interrupt () çağrısına kadar.

Usage:

• sleep (): zaman senkronizasyonu için;
• wait (): çoklu evre senkronizasyonu için.

Ref: fark sleepvewait

Basit bir deyişle, bekle bekle Başka bir iş parçacığı sizi çağırıncaya kadar, uyku belirli bir süre "sonraki ifadeyi yürütme" olur.

Ayrıca sleep, Thread sınıfında statik bir yöntemdir ve thread üzerinde çalışır, oysa wait () Object sınıfındadır ve bir nesnede çağrılır.

Başka bir nokta, bazı nesnelerde wait çağırdığınızda, dahil olan iş parçacığı nesneyi senkronize eder ve sonra bekler. :)

waitve sleepyöntemler çok farklı:

• sleep "uyanma" yolu yoktur,
• oysa wait"uyanma-up" bekleme süresi boyunca, başka bir iş parçacığı arayarak bir yolu vardır notifyya notifyAll.

Düşünmeye gel, isimler bu açıdan kafa karıştırıcı; Ancak sleepstandart bir isimdir ve waitgibidir WaitForSingleObjectveya WaitForMultipleObjectskazanın API.

Bu gönderiden : http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

wait () Yöntemi.

1) wait () yöntemini çağıran evre, tuttuğu kilidi açar.

2) Diğer evreler aynı kilit üzerinde notify () veya notifyAll () yöntemlerini çağırdıktan sonra evre kilidi yeniden kazanır.

3) senkronize blok içinde wait () yöntemi çağrılmalıdır.

4) objelerde her zaman wait () yöntemi çağrılır.

5) Bekleyen evreler notify () veya notifyAll () yöntemleri çağrılarak diğer evreler tarafından uyandırılabilir.

6) wait () yöntemini çağırmak için, iş parçacığının nesne kilidi olması gerekir.

sleep () yöntemi

1) sleep () yöntemini çağıran evre, sahip olduğu kilidi açmaz.

2) sleep () yöntemi senkronize blok içinde veya dışında çağrılabilir.

3) ipliklerde her zaman sleep () yöntemi çağrılır.

4) Uyku iplikleri diğer iplikler tarafından uyandırılamaz. Bunu yaparsanız, iş parçacığı InterruptedException atar.

5) sleep () yöntemini çağırmak için, iş parçacığının nesne kilidine sahip olması gerekmez.

Burada wait (), başka bir iş parçacığı tarafından bildirilene kadar bekleme durumunda olacak, ancak uyku () zamanının biraz geçeceği bir yer olacak ... sonra otomatik olarak Hazır durumuna geçecektir ...

1. wait()bir Objectsınıf yöntemidir .
   sleep()bir Threadsınıf yöntemidir .

2. sleep()iş parçacığının sleepx milisaniye durumuna geçmesine izin verir .
   Bir iplik uyku durumuna geçtiğinde it doesn’t release the lock.

3. wait()ipliğin kilidi açmasına izin verir ve goes to suspended state.
   Bu iş parçacığı aynı nesne için bir notify()veya notifAll()yöntem çağrıldığında etkin olur .

Uyku / kesinti ve bekleme / bildirme arasındaki potansiyel büyük fark,

• interrupt()sırasında çağırma sleep()her zaman bir istisna atar (örn. InterruptedException )
• notify()sırasında çağrı wait()yapmaz.

Gerekli olmadığında bir istisna oluşturmak verimsizdir. Birbirinizle yüksek oranda iletişim kuran dişleriniz varsa, her zaman kesinti çağrısı yapıyorsanız, CPU'nun toplam israfı olan bir çok istisna oluşturur.

Doğru - Sleep () bu iş parçacığının "uyku" yapmasına neden olur ve CPU söner ve diğer iş parçacıklarını (bağlam değiştirme olarak da bilinir) wheras'ı işleyeceğine inanıyorum.

Her ikisine de sahibiz çünkü kullanmadığınızda diğer kişilerin CPU'yu kullanmasına izin vermek mantıklı görünse de, aslında bağlam değiştirme için ek yük var - uykunun ne kadar sürdüğüne bağlı olarak, CPU döngülerinde daha pahalı olabilir daha fazla iş parçacığı değiştirmek için sadece birkaç ms için hiçbir şey yapmaz.

Ayrıca uyku durumunun bir bağlam anahtarını zorladığını unutmayın.

Ayrıca - genel olarak bağlam değiştirmeyi kontrol etmek mümkün değildir - Bekle sırasında işletim sistemi diğer iş parçacıklarını işlemeyi seçebilir (ve daha uzun bekler).

Yöntemler farklı şeyler için kullanılır.

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

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

Thread.sleep (n) olabilir kesilebilir, ancak Object.wait () gerekir bildirilecektir. Beklemek için maksimum süreyi belirtmek mümkündür: Object.wait(5000)bu nedenle wait, er kullanmak mümkün olacaktır , sleepancak daha sonra kilitlerle uğraşmak zorundasınız.

Her iki yöntem de uyku / bekleme sırasında cpu kullanmaz.

Yöntemler, benzer yapılar kullanılarak yerel kod kullanılarak uygulanır, ancak aynı şekilde uygulanmaz.

Kendiniz arayın: Yerel yöntemlerin kaynak kodu mevcut mu? Dosya /src/share/vm/prims/jvm.cppbaşlangıç ​​noktasıdır ...

Bekleyin () ve uyku () Farklılıklar?

Thread.sleep () Çalışması tamamlandıktan sonra kilidi sadece herkese serbest bırakın. kilidi asla kimseye bırakmayıncaya kadar.

  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 () Bekleme aşamasına gittiğinde, tuşu serbest bırakacak ve parametreye bağlı olarak birkaç saniye bekleyecektir.

Örneğin:

kahveyi sağ elinize alırsınız, aynı elden başka birini alabilirsin, ne zaman bırakılırsa burada sadece aynı tipte başka bir nesne alırsınız. Ayrıca. Bu uyku () uyku zaman herhangi bir iş yoktu, sadece uyku yapıyorsun .. burada da aynı.

Bekle(). sen beklerken başka bir tane daha alsan, bekle

film oynuyorsunuz veya sisteminizdeki herhangi bir şey aynı anda birden fazla oynatamıyorsunuz, burası burada, başka birini kapatıp seçtiğinizde beklemek denilen bir film veya şarkı demek

waitkilidi serbest bırakır ve sleepaçmaz. Bekleme durumu bir iplik en kısa sürede uyanma için uygun notifyveya notifyAlldenir. Ancak sleepiplik durumunda kilidi tutar ve sadece uyku süresi bittiğinde uygun olur.

sleep()yöntemi, geçerli iş parçacığının belirtilen durumdan çalışma durumundan engelleme durumuna geçmesine neden olur. Geçerli iş parçacığı herhangi bir nesnenin kilidine sahipse, onu tutmaya devam eder, bu da diğer iş parçacıklarının o sınıf nesnesindeki herhangi bir senkronize yöntemi çalıştıramayacağı anlamına gelir.

wait() yöntemi, geçerli iş parçacığının belirli bir süre boyunca veya bildirilene kadar blok durumuna geçmesine neden olur, ancak bu durumda iş parçacığı, nesnenin kilidini serbest bırakır (yani, diğer iş parçacıklarının çağıran nesnenin senkronize edilmiş yöntemlerini yürütebileceği anlamına gelir.

Bence her iki mekanizma arasındaki temel fark uyku / kesmenin evreleri ele almanın en temel yolu olmasına karşın, bekle / bildir, evre iletişimini kolaylaştırmayı amaçlayan bir soyutlamadır. Bu, uyku / kesmenin herhangi bir şey yapabileceği anlamına gelir, ancak bu özel görevin yapılması daha zordur.

Bekle / bildir neden daha uygundur? İşte bazı kişisel düşünceler:

1. Merkezileştirmeyi zorunlu kılar. Tek bir paylaşılan nesne ile bir grup iş parçacığı arasındaki iletişimi koordine eder. Bu işi çok basitleştirir.

2. Senkronizasyonu zorunlu kılar. Çünkü programcı senkronize edilmiş bir blokta beklemek / bildirmek için çağrıyı sarar.

3. İplik kökeni ve numarasından bağımsızdır. Bu yaklaşımla, diğer konuları düzenlemeden veya mevcut olanları takip etmeden keyfi olarak daha fazla konu ekleyebilirsiniz. Uyku / kesmeyi kullandıysanız, önce uyku ipliklerine yapılan referansları tutmanız ve daha sonra bunları tek tek el ile kesmeniz gerekir.

Bunu açıklamak iyi olan gerçek yaşamdan bir örnek, klasik bir restoran ve personelin aralarında iletişim kurmak için kullandıkları yöntemdir: Garsonlar, müşteri taleplerini merkezi bir yerde (mantar pano, masa vb.) bir zil çalar ve mutfaktaki işçiler bu tür istekleri almaya gelirler. Herhangi bir kursa hazır olduktan sonra, garsonların farkında olması ve müşterilere götürmesi için mutfak personeli zili tekrar çalar.

Uykuya örnek kilit açmıyor ve bekleme

Burada iki sınıf var:

1. Main : Ana yöntem ve iki iş parçacığı içerir.

2. Singleton : getInstance () ve getInstance (boolean isWait) adlı iki statik yöntemle singleton sınıfıdır.

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

ve

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;

 }
}

Şimdi bu örneği çalıştırın, aşağıda çıktıyı elde edersiniz:

_instance :null
Both singleton are same

Burada threadA ve threadB tarafından oluşturulan Singleton örnekleri aynıdır. Bu, threadB kilidinin serbest kalmasına kadar dışarıda beklediği anlamına gelir.

Şimdi Thread.sleep (500) 'e yorum yaparak Singleton.java dosyasını değiştirin; yöntem ve uncommenting Singleton.class.wait (500); . Burada Singleton.class.wait (500) nedeniyle; yöntem threadA tüm edinme kilitlerini serbest bırakacak ve “Runnable” durumuna geçecektir, threadB senkronize bloğa girmek için değişiklik alacaktır.

Şimdi tekrar çalıştırın:

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

Burada threadA ve threadB tarafından oluşturulan Singleton örnekleri aynı değildir çünkü threadB senkronize bloğa girme değişikliğine sahiptir ve 500 milisaniye sonra threadA son konumundan başlayıp bir tane daha Singleton nesnesi yaratmıştır.

Senkronize bloktan çağrılmalıdır: wait() yöntem her zaman senkronize bloktan çağrılır, yani wait()yöntemin çağrılmadan önce nesne izleyicisini kilitlemesi gerekir. Ancak sleep()yöntem dış senkronize bloktan çağrılabilir, yani sleep()yöntem herhangi bir nesne izleyicisine ihtiyaç duymaz.

IllegalMonitorStateException: eğer wait()yöntem IllegalMonitorStateExceptionçalışma zamanında atılandan nesne kilidi alınmadan çağrılır , ancak sleep()yöntem asla böyle bir istisna alamaz .

Hangi sınıfa wait() aittir : yöntem java.lang.Objectsınıfa sleep()aittir, yöntem java.lang.Threadsınıfa aittir .

Nesne veya iş parçacığında çağrılır: wait() yöntem nesnelerde çağrılır ancak sleep()yöntem nesnelerde değil Konularda çağrılır.

Konu durumu:wait() yöntemi nesne üzerinde çağrılır, o Düzenlenen nesnenin monitör bekleme durumuna koşarak gider ve yalnızca katedilebilen durumuna dönebilir iplik notify()veya notifyAll()bu nesne üzerinde çağrılır yöntemi. Ve daha sonra iş parçacığı zamanlayıcı bu iş parçacığı çalıştırılabilir durumdan çalışma durumuna geçmek için zamanlar. ne zaman sleep()iş parçacığı üzerinde denir o bekleme durumu için çalışmasını gider ve uyku süresi dolduğunda çalıştırılabilir duruma dönebilir.

Senkronize bloktan çağrıldığında: zaman wait()yöntem nesne kilit iplik yaprakları denir. Fakatsleep() yöntem, senkronize blok veya yöntem iş parçacığından çağrıldığında nesne kilidi bırakmaz.

Daha Fazla Referans İçin

Kehanet dokümantasyon sayfasında wait () yöntemi Object:

public final void wait()

1. Geçerli iş parçacığının, başka bir iş parçacığı bu nesne için notify()yöntemi veya yöntemi çağırana kadar beklemesine neden olur notifyAll(). Başka bir deyişle, bu yöntem tam olarak aramayı yapıyormuş gibi davranır wait(0).
2. Geçerli evre bu nesnenin monitörüne sahip olmalıdır. İş parçacığı bu monitörün sahipliğini serbest bırakır ve başka bir iş parçacığı bu nesnenin monitöründe bekleyen iş parçacıklarının uyanmasını bildirene kadar bekler
3. kesintiler ve sahte uyandırma işlemleri mümkündür
4. Bu yöntem yalnızca bu nesnenin monitörünün sahibi olan bir iş parçacığı tarafından çağrılmalıdır

Bu yöntem

1. IllegalMonitorStateException - geçerli evre nesnenin monitörünün sahibi değilse.

2. InterruptedException- herhangi bir evre mevcut iş parçacığı bir bildirim beklerken önce ya da sırasında geçerli iş parçacığı kesintiye uğradıysa. Bu istisna atıldığında geçerli iş parçacığının kesilmiş durumu temizlenir.

Class () yöntemi ile ilgili oracle dokümantasyon sayfasından Thread:

public static void sleep(long millis)

1. Geçerli olarak yürütülen iş parçacığının, sistem zamanlayıcılarının ve zamanlayıcılarının kesinliği ve doğruluğuna bağlı olarak, belirtilen milisaniye boyunca uyku moduna geçmesine (geçici olarak yürütmeyi durdurmasına) neden olur.
2. İş parçacığı hiçbir monitörün sahipliğini kaybetmez.

Bu yöntem atar:

1. IllegalArgumentException - milis değeri negatifse

2. InterruptedException- herhangi bir iş parçacığı mevcut iş parçacığını kesintiye uğrattıysa. Bu istisna atıldığında geçerli iş parçacığının kesilmiş durumu temizlenir.

Diğer önemli farklar:

wait()statik yöntemden sleep()(sınıf yöntemi) farklı olarak statik olmayan bir yöntemdir (örnek yöntemi).

wait()oysa senkronize bir yöntem içinde verilmektedir sleep(), çünkü olan eşzamanlı olmayan bir yöntem içinde verilen wait()yöntem nesnenin üzerindeki kilidi serbest bırakacak ancak sleep()veya yield()serbest yapar lock().

• Yöntem wait(1000), geçerli iş parçacığının bir saniyeye kadar uyumasına neden olur .
  • Bir iş parçacığı notify()veyanotifyAll() yöntem çağrısı alırsa 1 saniyeden az uyuyabilir .
• sleep(1000)Geçerli iş parçacığının tam olarak 1 saniye uyumasına neden olma çağrısı .
  • Ayrıca uyku ipliği herhangi bir kaynağı kilitlemez . Ama bekleyen iş parçacığı yapar.

Aslında, tüm bunlar Java belgelerinde açıkça tanımlanmıştır (ancak bunu sadece cevapları okuduktan sonra anladım).

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

wait () - Geçerli iş parçacığının bu nesnenin monitörüne sahip olması gerekir. İş parçacığı, bu monitörün sahipliğini serbest bırakır ve başka bir iş parçacığı, bu nesnenin monitöründe bekleyen iş parçacıklarına, bildirme yöntemine veya notifyAll yöntemine yapılan bir çağrı yoluyla uyanmasını bildirene kadar bekler. İş parçacığı daha sonra monitörün sahipliğini yeniden elde edene ve yürütmeyi sürdürene kadar bekler.

sleep () - Sistem zamanlayıcılarının ve zamanlayıcılarının kesinliği ve doğruluğuna bağlı olarak, yürütülmekte olan iş parçacığının belirtilen milisaniye boyunca uyku moduna geçmesine (geçici olarak yürütmeyi durdurmasına) neden olur. İş parçacığı hiçbir monitörün sahipliğini kaybetmez.