Görünüşe göre olmamalı (ve yapmamalı) rağmen bu Java programı neden sona eriyor?

Bugün laboratuvarımdaki hassas bir operasyon tamamen yanlış gitti. Bir elektron mikroskobu üzerindeki bir aktüatör sınırlarını aştı ve bir olay zincirinden sonra 12 milyon dolarlık ekipman kaybettim. Hatalı modülde 40K hattı üzerinde daralttım:

import java.util.*;

class A {
    static Point currentPos = new Point(1,2);
    static class Point {
        int x;
        int y;
        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    public static void main(String[] args) {
        new Thread() {
            void f(Point p) {
                synchronized(this) {}
                if (p.x+1 != p.y) {
                    System.out.println(p.x+" "+p.y);
                    System.exit(1);
                }
            }
            @Override
            public void run() {
                while (currentPos == null);
                while (true)
                    f(currentPos);
            }
        }.start();
        while (true)
            currentPos = new Point(currentPos.x+1, currentPos.y+1);
    }
}

Bazı örnekler çıktı alıyorum:

$ java A
145281 145282
$ java A
141373 141374
$ java A
49251 49252
$ java A
47007 47008
$ java A
47427 47428
$ java A
154800 154801
$ java A
34822 34823
$ java A
127271 127272
$ java A
63650 63651

Burada herhangi bir kayan nokta aritmetiği olmadığından ve hepimiz işaretli tam sayıların Java'da taşma üzerinde iyi davrandığını bildiğimiz için, bu kodda yanlış bir şey olmadığını düşünürdüm. Ancak, programın çıkış durumuna ulaşmadığını gösteren çıktıya rağmen, çıkış durumuna ulaştı (hem ulaşıldı hem de ulaşılmadı?). Neden?

Bunun bazı ortamlarda olmadığını fark ettim. 64 bit Linux üzerinde OpenJDK 6 kullanıyorum.

Açıkçası currentPos'a yazma gerçekleşmez-okunmadan önce, ama sorunun nasıl olabileceğini göremiyorum.

currentPos = new Point(currentPos.x+1, currentPos.y+1);xve y(0) 'a varsayılan değerler yazıp ardından yapıcıya başlangıç ​​değerlerini yazmak dahil birkaç şey yapar . Nesneniz güvenli bir şekilde yayınlanmadığı için bu 4 yazma işlemi derleyici / JVM tarafından serbestçe yeniden düzenlenebilir.

Bu nedenle, okuma iş parçacığının bakış açısından x, yeni değeriyle, ancak yvarsayılan değeri 0 ile okumak yasal bir yürütmedir . İfadeye ulaştığınız zaman println(bu arada senkronize edilir ve bu nedenle okuma işlemlerini etkiler), değişkenlerin başlangıç ​​değerleri vardır ve program beklenen değerleri yazdırır.

İşaretleme currentPosolarak volatilenesne inşaat sonrası mutasyona uğrar gerçek kullanım durumunda ise, - senin nesne etkin bir değişmez olan güvenli yayını sağlayacak volatilegarantiler yeterli olmayacaktır ve tutarsız bir nesneyi tekrar görebiliyordu.

Alternatif olarak, Pointkullanmadan bile güvenli yayın yapılmasını sağlayacak olan değişmez hale getirebilirsiniz volatile. Değişmezliği sağlamak için işaretlemeniz xve ysonlandırmanız yeterlidir .

Bir yan not olarak ve daha önce de belirtildiği synchronized(this) {}gibi, JVM tarafından bir no-op olarak kabul edilebilir (davranışı yeniden üretmek için dahil ettiğinizi anlıyorum).

İş currentPosparçacığının dışında değiştirildiği için şu şekilde işaretlenmelidir volatile:

static volatile Point currentPos = new Point(1,2);

Uçucu olmadan, ana iş parçacığında yapılan currentPos güncellemelerinde iş parçacığının okunacağı garanti edilmez. Dolayısıyla currentPos için yeni değerler yazılmaya devam ediyor, ancak iş parçacığı performans nedeniyle önceki önbelleğe alınmış sürümleri kullanmaya devam ediyor. CurrentPos'u yalnızca bir iş parçacığı değiştirdiğinden, performansı artıracak kilitler olmadan kurtulabilirsiniz.

Değerleri karşılaştırmada ve daha sonra görüntülemede kullanmak için değerleri iş parçacığında yalnızca bir kez okursanız sonuçlar çok farklı görünür. Bunu yaptığımda aşağıdakiler xher zaman gibi 1ve yarasında değişir 0ve bazı büyük tamsayılar. Ben bu noktada davranışı volatileanahtar kelime olmadan biraz tanımsız olduğunu düşünüyorum ve kod JIT derleme böyle davranarak katkıda olması mümkündür. Ayrıca ben boş synchronized(this) {}blok yorum sonra kod da çalışır ve kilitleme yeterli gecikme neden olduğundan currentPosve alanları önbellekten kullanılan yerine yeniden olduğundan şüpheleniyorum .

int x = p.x + 1;
int y = p.y;

if (x != y) {
    System.out.println(x+" "+y);
    System.exit(1);
}

Senkronizasyon olmadan 2 iş parçacığı arasında paylaşılan sıradan belleğiniz, 'currentpos' başvurusu ve Point nesnesi ve arkasındaki alanları vardır. Bu nedenle, ana iş parçacığında bu belleğe gerçekleşen yazma işlemleri ile oluşturulan iş parçacığındaki okumalar (T olarak adlandırılır) arasında tanımlı bir sıralama yoktur.

Ana iş parçacığı aşağıdaki yazma işlemlerini yapıyor (noktanın ilk kurulumunu yok saymak, px ve py'nin varsayılan değerlere sahip olmasına neden olur):

• piksel yapmak
• py'ye
• Şu anki konuma

Senkronizasyon / engeller açısından bu yazmalarla ilgili özel bir şey olmadığından, çalışma zamanı T iş parçacığının bunları herhangi bir sırada görmesine izin vermekte serbesttir (elbette ana iş parçacığı her zaman program sırasına göre sipariş edilen yazma ve okumaları görür) ve gerçekleşir T.'deki okumalar arasındaki herhangi bir noktada

Yani T yapıyor:

1. akımları p'ye okur
2. px ve py'yi oku (her iki sırayla)
3. karşılaştır ve dalı al
4. px ve py (siparişlerden birini) okuyun ve System.out.println'i arayın

Ana yazmalar ve T'deki okumalar arasında herhangi bir sipariş ilişkisi olmadığı göz önüne alındığında, T, currentpos.y veya currentpos.x'e yazmadan önce main'un currentpos'a yazdığını görebileceğinden, bunun sonucunuzu üretebileceği açıkça birkaç yol vardır :

1. Önce x yazma gerçekleşmeden önce currentpos.x okur - 0 alır, sonra y yazma gerçekleşmeden önce currentpos.y okur - 0 alır. Yazmalar T. tarafından görülebilir hale gelir. System.out.println denir.
2. Önce x yazma gerçekleştikten sonra currentpos.x, sonra y yazma gerçekleşmeden önce currentpos.y değerini okur - 0 değerini alır. Yazılar T ... vb. Tarafından görünür hale gelir.
3. Önce currentpos.y, y yazma gerçekleşmeden önce (0), sonra x write'dan sonra currentpos.x değerini doğru olarak değiştirir. vb.

ve benzerleri ... Burada bir dizi veri yarışı var.

Buradaki kusurlu varsayımın, bu satırdan kaynaklanan yazımların, yürütme iş parçacığının program sırasında tüm iş parçacıkları arasında görünür hale getirildiğini düşündüğünden şüpheleniyorum:

currentPos = new Point(currentPos.x+1, currentPos.y+1);

Java böyle bir garanti vermez (performans için korkunç olurdu). Programınız diğer konulardaki okumalara göre yazmaların garantili olarak sıralanması gerektiğinde daha fazlası eklenmelidir. Diğerleri x, y alanlarını sonlandırmayı veya alternatif olarak currentpos'u uçucu hale getirmeyi önerdi.

• X, y alanlarını sonlandırırsanız, Java, tüm iş parçacıklarında değerlerinin yazma işlemlerinin yapıcı dönmeden önce görüleceğini garanti eder. Bu nedenle, currentpos'a atama yapıcıdan sonra olduğu için, T iş parçacığının yazıları doğru sırada görmesi garanti edilir.
• Currentpos'u geçici yaparsanız, Java, bunun diğer senkronizasyon noktaları için toplam sipariş edilen bir senkronizasyon noktası olduğunu garanti eder. Genelde x ve y yazmaları currentpos'a yazılmadan önce gerçekleşmelidir, o zaman başka bir iş parçacığındaki currentpos okumaları daha önce gerçekleşen x, y yazımlarını da görmelidir.

Final kullanmak, alanları değiştirilemez hale getirme avantajına sahiptir ve böylece değerlerin önbelleğe alınmasına izin verir. Uçucu kullanmak currentpos'un her yazma ve okunuşunda senkronizasyona yol açarak performansa zarar verebilir.

Kanlı detayları için Java Language Spec'in 17. bölümüne bakın: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html

(İlk cevap, JLS garantili uçucunun yeterli olduğundan emin olmadığım için daha zayıf bir bellek modeli olduğunu varsaydı. Cevap, assylias'ın yorumunu yansıtacak şekilde düzenlendi, Java modelinin daha güçlü olduğunu gösteriyor - daha önce gerçekleşen geçişli - ve bu yüzden mevcutlar üzerindeki uçucu da yeterli ).

Yazma ve okumaları senkronize etmek için bir nesne kullanabilirsiniz. Aksi takdirde, diğerlerinin daha önce söylediği gibi, p.x + 1 ve py iki okumanın ortasında currentPos'a bir yazma gerçekleşir

new Thread() {
    void f(Point p) {
        if (p.x+1 != p.y) {
            System.out.println(p.x+" "+p.y);
            System.exit(1);
        }
    }
    @Override
    public void run() {
        while (currentPos == null);
        while (true)
            f(currentPos);
    }
}.start();
Object sem = new Object();
while (true) {
    synchronized(sem) {
        currentPos = new Point(currentPos.x+1, currentPos.y+1);
    }
}

CurrentPos'a iki kez erişiyorsunuz ve bu iki erişim arasında güncellenmediğini garanti etmiyorsunuz.

Örneğin:

1. x = 10, y = 11
2. işçi iş parçacığı px 10 olarak değerlendirir
3. ana iş parçacığı güncellemeyi yürütür, şimdi x = 11 ve y = 12
4. işçi iş parçacığı py 12 olarak değerlendirir.
5. işçi iş parçacığı 10 + 1! = 12 olduğunu fark eder, bu nedenle yazdırır ve çıkar.

Aslında iki farklı noktayı karşılaştırıyorsunuz .

CurrentPos'u uçucu hale getirmenin bile işçi iş parçacığının iki ayrı okuması olduğundan sizi bundan koruyamayacağını unutmayın.

Bir ekle

boolean IsValid() { return x+1 == y; }

puan sınıfına. Bu, x + 1 == y kontrol edilirken currentPos değerinin yalnızca bir değerinin kullanılmasını sağlar.