Java, bu son derece açık veya başka bir yerde yanıtlanmışsa üzgünüz karışıklık

Question

. Hiçbir şey bulamadım. Aşağıdaki kod var:

public class SimpleThread extends Thread { 
    public static Integer sharedVal = 0; 
    public SimpleThread() { 

    } 
    @Override 
    public void run() { 
     while(true) {   
      iterator(); 
     } 
    } 

    public void theSleeper() { 
     System.out.println("Thread: " + this.getId() + " is going to sleep!"); 
     try { 
      this.sleep(5000); 
     } catch(Exception e) { 

     } 
    } 

    public void iterator() { 
     synchronized(sharedVal) { 
      System.out.println("Iterating sharedVal in thread: " + this.getId()); 
      sharedVal++; 
      System.out.println(sharedVal); 
      theSleeper(); 
      System.out.println("Thread : " + getId() + " is done sleeping, trying to iterate again..."); 
     } 
    } 
} 

Bu SimpleThread sınıfının iki örneğini oluşturmak ve çalıştırmak yöntemlerini yürütmek. Ben gibi bir şey görmeyi umuyoruz: Konu 9 artan ... Konu 9 uyku ... (5 saniye sonra) Konu 10 artım .... Konu 10 uyku .... Bunu bekliyorum çünkü yineleyici yöntemini kilitliyorum, böylece bir kerede yalnızca bir iş parçacığı girebilmeli. Bunun yerine, her iki iş parçacığının artması ve ardından her ikisinin de 5 saniye beklemesidir. Bu sonsuza dek tekrarlanır. Burada beklenen davranışa sahip olmak için neyi özlüyorum? Çok teşekkürler!

DÜZENLEME: Yeni bir genel statik değişken oluşturdum: public static Nesne theLock = new Object(). Şimdi, yineleyici yönteminde, senkronize (TheLock) yapıyorum. Çıkış beklediğimden daha fazla, çünkü kilit asla değişmiyor. Ancak, şimdi sadece iplik 9, yönteme giriyor. Görünüşe göre, iplik 10 açlıktan ölüyor ve asla bir dönüş yapmıyor. Bu garip görünüyor. Sadece birkaç kez değil, her zaman sadece iplik 9 tekrarlanıyor ve uyuyor. 9, 10, 9, 10 olacağını düşünürdüm. Veya belki de 9, 10, 10, 10, 9, 10, 9, 9, 10, vb. Gibi rasgele bir dağılım.

EDIT2: Ne olduğunu görüyorum. Şimdi oluyor. 9. parçanın kilidi var. İş parçacığı 10, işleve girmeye çalışır, ancak hemen beklemek söylenir. İşlev tamamlandıktan sonra, hala iş parçacığı 9s olabilir. Iş parçacığı 9 daha sonra kilidi siler ve döngü devam eder. Bir dönüş almak için iş parçacığı 10 için zamanlama penceresi çok küçüktür ve bir dönüş alsaydı muhtemelen açlıktan 9 olurdu. Bu söyleniyor, iterator() içinde senkronize blok sonra verim() koyarak daha fazla yapmak için görünmüyor adil. Metod hakkındaki yorumları okudum ve programlayıcı aslında getiri() görmezden gelebilir.

Answer 1

Sorununuz burada bulunduğu

senkronize (SympleThread.class): Bunun yerine senkronizasyonu için aşağıdaki ifadeyi kullanabilirsiniz nedeniyle Autoboxing için, bu çizgi

sharedVal++; 

bu çevirir:

sharedVal = Integer.valueOf(sharedVal.intValue() + 1); 

, her çalıştırıldığında yeni bir 10 nesnesi oluşturur, böylece her seferinde synchronized bloğunun izlediği zaman, kilitlenir. farklı bir değer.

private final static Object LOCK = new Object(); 

ve sonra yerine synchronized (LOCK) {... kullanmak için senkronizasyon değiştirin:

eşitlemek için özel bir nesne kullanın.

(Ayrıca kilitlemek için getClass() kullanabilirsiniz, ama ben şahsen kamu dünyaya kilit nesneleri göstermek için sevmiyorum)

Answer 2

Arttırma yaparken, yeni bir tamsayı örneği ve kilitleme için yeni bir nesne oluşturursunuz.

Answer 3

Etkili ipler her yinelemesini kullandığınız kilit değişiyor: ++ tamsayı yeni bir örneğini oluşturur üzerinde (Tamsayı sınıfı değişmez)

Answer 4

sharedVal üyesi varible örneği Eğer ++ sharedVal gerçekleştirdiğinizde değişiyor.