Perbedaan antara status thread WAIT dan BLOCKED

Apa perbedaan antara status thread WAIT dan status thread BLOCKED?

The Thread.State dokumentasi :

Diblokir
Utas yang diblokir menunggu kunci monitor berada dalam status ini.

Menunggu
Sebuah thread yang menunggu tanpa batas waktu thread lain untuk melakukan tindakan tertentu berada dalam status ini

tidak menjelaskan perbedaannya kepada saya.

Sebuah utas akan menunggu status setelah memanggil wait()Objek. Ini disebut Status Menunggu . Setelah utas mencapai status menunggu, utas harus menunggu hingga utas lain memanggil notify()atau notifyAll()pada objek.

Setelah utas ini diberi tahu, utas tidak akan dapat dijalankan. Bisa jadi utas lain juga diberitahukan (menggunakan notifyAll()) atau utas pertama belum menyelesaikan pekerjaannya, sehingga masih diblokir sampai mendapat kesempatan. Ini disebut Status Diblokir . Keadaan diblokir akan terjadi setiap kali utas mencoba untuk mendapatkan kunci pada objek dan beberapa utas lain sudah menahan kunci.

Setelah utas lain keluar dan utas ini berpeluang, utas tersebut pindah ke status Runnable setelah itu memenuhi syarat pekerjaan pengambilan berdasarkan mekanisme threading JVM dan pindah ke status berjalan.

Perbedaannya relatif sederhana.

Dalam BLOCKEDstatus, utas akan memasuki synchronizedblok, tetapi ada utas lain yang sedang berjalan di dalam synchronizedblok pada objek yang sama. Utas pertama kemudian harus menunggu utas kedua keluar dari bloknya.

Dalam WAITINGstatus, utas sedang menunggu sinyal dari utas lain. Ini biasanya terjadi dengan menelepon Object.wait(), atau Thread.join(). Utas kemudian akan tetap dalam keadaan ini sampai utas lain memanggil Object.notify(), atau mati.

Perbedaan penting antara status diblokir dan menunggu adalah dampaknya pada penjadwal. Sebuah utas dalam keadaan diblokir bersaing untuk mendapatkan kunci; utas itu masih dihitung sebagai sesuatu yang perlu diservis oleh penjadwal, mungkin diperhitungkan dalam keputusan penjadwal tentang berapa banyak waktu untuk memberikan utas yang berjalan (sehingga dapat memberi kesempatan utas memblokir pada kunci).

Setelah utas berada dalam status tunggu, tekanan yang diberikan pada sistem diminimalkan, dan penjadwal tidak perlu mengkhawatirkannya. Ini tidak aktif sampai menerima pemberitahuan. Kecuali fakta bahwa itu membuat utas OS terisi, itu sepenuhnya keluar dari permainan.

Inilah sebabnya mengapa menggunakan notifyAll kurang dari ideal, itu menyebabkan sekelompok utas yang sebelumnya dengan senang hati tidak aktif sehingga tidak membebani sistem menjadi terbangun, di mana kebanyakan dari mereka akan memblokir sampai mereka dapat memperoleh kunci, menemukan kondisinya. menunggu tidak benar, dan kembali menunggu. Akan lebih baik jika memberi tahu hanya utas yang memiliki peluang untuk membuat kemajuan.

(Menggunakan ReentrantLock alih-alih kunci intrinsik memungkinkan Anda memiliki beberapa ketentuan untuk satu kunci, sehingga Anda dapat memastikan utas yang diberi tahu adalah utas yang menunggu pada kondisi tertentu, menghindari bug pemberitahuan hilang jika utas mendapat pemberitahuan untuk sesuatu yang tidak bisa ditindaklanjuti.)

Perspektif yang disederhanakan untuk menafsirkan thread dump:

• TUNGGU - Saya menunggu untuk diberi pekerjaan, jadi saya menganggur sekarang.
  
• DIBLOKIR - Saya sibuk mencoba menyelesaikan pekerjaan tetapi utas lain menghalangi jalan saya, jadi saya menganggur sekarang.
  
• DAPAT DIJALANKAN ... (Metode Asli) - Saya memanggil untuk MENJALANKAN beberapa kode asli (yang belum selesai) sejauh menyangkut JVM, Anda DAPAT DIJALANKAN dan tidak dapat memberikan informasi lebih lanjut. Contoh umum adalah metode pendengar soket asli yang dikodekan dalam C yang sebenarnya menunggu lalu lintas datang, jadi saya menganggur sekarang. Dalam situasi itu, ini dapat dilihat sebagai jenis TUNGGU khusus karena kami sebenarnya tidak MENJALANKAN (tidak ada CPU yang terbakar) sama sekali tetapi Anda harus menggunakan dump thread OS daripada dump thread Java untuk melihatnya.

Diblokir- Utas Anda dalam keadaan siklus hidup utas yang dapat dijalankan dan mencoba mendapatkan kunci objek. Tunggu- Utas Anda dalam keadaan menunggu siklus hidup utas dan menunggu sinyal pemberitahuan datang dalam keadaan utas yang dapat dijalankan.

lihat contoh ini:

demonstrasi status utas.

/*NEW- thread object created, but not started.
RUNNABLE- thread is executing.
BLOCKED- waiting for monitor after calling wait() method.
WAITING- when wait() if called & waiting for notify() to be called.
  Also when join() is called.
TIMED_WAITING- when below methods are called:
 Thread.sleep
 Object.wait with timeout
 Thread.join with timeout
TERMINATED- thread returned from run() method.*/
public class ThreadBlockingState{

public static void main(String[] args) throws InterruptedException {
    Object obj= new Object();
    Object obj2 = new Object();
    Thread3 t3 = new Thread3(obj,obj2);
    Thread.sleep(1000);
    System.out.println("nm:"+t3.getName()+",state:"+t3.getState().toString()+
            ",when Wait() is called & waiting for notify() to be called.");
    Thread4 t4 = new Thread4(obj,obj2);
    Thread.sleep(3000);
    System.out.println("nm:"+t3.getName()+",state:"+t3.getState().toString()+",After calling Wait() & waiting for monitor of obj2.");
    System.out.println("nm:"+t4.getName()+",state:"+t4.getState().toString()+",when sleep() is called.");
}

}
class Thread3 extends Thread{
Object obj,obj2;
int cnt;
Thread3(Object obj,Object obj2){
    this.obj = obj;
    this.obj2 = obj2;
    this.start();
}

@Override
public void run() {
    super.run();
    synchronized (obj) {
        try {
            System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",Before Wait().");
            obj.wait();             
            System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",After Wait().");
            synchronized (obj2) {
                cnt++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}
class Thread4 extends Thread{
Object obj,obj2;
Thread4(Object obj,Object obj2){
    this.obj = obj;
    this.obj2 = obj2;
    this.start();
}

@Override
public void run() {
    super.run();
    synchronized (obj) {
        System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",Before notify().");
        obj.notify();
        System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",After notify().");
    }
    synchronized (obj2) {
        try {
            Thread.sleep(15000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}