BEKLE ve ENGELLENMİŞ iş parçacığı durumları arasındaki fark

İplik durumu BEKLEME ve BLOKE edilmiş iplik durumu arasındaki fark nedir?

Thread.State belgeleri :

Engellendi
Bir monitör kilidi bekleyen iş parçacığı bu durumdadır.

Bekleniyor
Başka bir iş parçacığının belirli bir eylemi gerçekleştirmesini süresiz olarak bekleyen bir iş parçacığı bu durumda

bana farkı açıklamıyor.

Bir iş parçacığı wait(), bir Nesneyi çağırdığında bekleme durumuna geçer . Buna Bekleme Durumu denir . Bir iş parçacığı bekleme durumuna ulaştığında, başka bir iş parçacığı çağırana kadar notify()veya notifyAll()nesne üzerinde beklemesi gerekecektir .

Bu iş parçacığı bildirildikten sonra çalıştırılabilir olmayacaktır. Diğer iş parçacığı da bildirilmiş (kullanılarak notifyAll()) veya ilk iş parçacığı işini bitirmemiş olabilir, bu nedenle şansı elde edilene kadar hala engellenir. Buna Engellenmiş Durum denir . Bir iş parçacığı nesne üzerinde kilit almaya çalıştığında ve başka bir iş parçacığı zaten kilidi tuttuğunda bir Engellenmiş durumu ortaya çıkar.

Diğer iş parçacıkları ayrıldıktan ve bu iş parçacığı şansı bir kez, Çalıştırılabilir duruma geçer, bundan sonra JVM iş parçacığı mekanizmasına göre uygun alma işi olur ve çalışma durumuna geçer.

Fark nispeten basit.

Durumda BLOCKED, bir iş parçacığı bir synchronizedbloğa girmek üzeredir , ancak synchronizedaynı nesne üzerindeki bir bloğun içinde şu anda çalışan başka bir iş parçacığı vardır . İlk iş parçacığı daha sonra ikinci iş parçacığının bloğundan çıkmasını beklemelidir.

Durumda WAITING, bir iş parçacığı başka bir iş parçacığından bir sinyal bekliyor. Bu genellikle Object.wait(), veya Thread.join(). İş parçacığı, başka bir iş parçacığı çağırana Object.notify()veya ölene kadar bu durumda kalacaktır .

Engellenen ve bekleme durumları arasındaki önemli fark, zamanlayıcı üzerindeki etkidir. Engellenmiş durumdaki bir iş parçacığı kilit için yarışıyor; bu iş parçacığı yine de zamanlayıcının hizmet vermesi gereken bir şey olarak sayılır, muhtemelen programlayıcının çalışan iş parçacıkları vermesi için ne kadar süre vereceğine dair kararlarında hesaba katılır (böylece iş parçacıklarının kilit üzerindeki engelleme şansı verebilir).

Bir iş parçacığı bekleme durumunda olduğunda, sisteme yüklediği stres en aza indirilir ve programlayıcının bunun için endişelenmesine gerek kalmaz. Bir bildirim alana kadar uykuda kalır. Bir işletim sistemi iş parçacığını meşgul tutması dışında, tamamen oyun dışıdır.

Bu nedenle notifyAll'ı kullanmak idealden daha azdır, daha önce mutlu bir şekilde uykuda olan bir grup iş parçacığının uyanmasına neden olur, çoğu kilit elde edene kadar bloke eder, bulundukları durumu bulurlar. beklemek doğru değildir ve beklemeye geri dönün. Yalnızca ilerleme sağlama şansı olan konuların bildirilmesi tercih edilir.

(İçsel kilitler yerine ReentrantLock'u kullanmak, bir kilit için birden fazla koşula sahip olmanızı sağlar, böylece bildirilen iş parçacığının belirli bir koşulu bekleyen bir iş parçacığı olduğundan emin olabilirsiniz ve bir iş parçacığının bildirilmesi durumunda kayıp bildirim hatasını önleyebilirsiniz. üzerinde hareket edemeyeceği bir şey.)

İş parçacığı dökümlerini yorumlamak için basitleştirilmiş perspektif:

• BEKLE - Biraz iş verilmesini bekliyorum, bu yüzden şu anda boştayım.
  
• ENGELLENDİ - İşi halletmekle meşgulüm ama yolumda başka bir konu duruyor, bu yüzden şu anda boştayım.
  
• ÇALIŞTIRILABİLİR ... (Yerel Yöntem) - JVM söz konusu olduğunda bazı yerel kodları ÇALIŞTIRMAK için çağırdım (henüz bitmedi), ÇALIŞTIRILABİLİRSİNİZ ve daha fazla bilgi veremez. Yaygın bir örnek, aslında herhangi bir trafiğin gelmesini bekleyen, C kodlu yerel bir yuva dinleyici yöntemi olabilir, bu nedenle şu anda boştayım. Bu durumda, aslında ÇALIŞMIYORUZ (CPU yakma yok), ancak bunu görmek için bir Java iş parçacığı dökümü yerine bir işletim sistemi iş parçacığı dökümü kullanmanız gerekeceğinden, bu özel bir BEKLEME türü olarak görülebilir.

Engellendi - İş parçacığınız, iş parçacığı yaşam döngüsünün çalıştırılabilir durumunda ve nesne kilidi elde etmeye çalışıyor. Bekle - İş parçacığınız iş parçacığı yaşam döngüsünün bekleme durumunda ve iş parçacığının çalıştırılabilir durumuna gelmesini bildirme sinyalini bekliyor.

bu örneğe bakın:

iş parçacığı durumlarının gösterimi.

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