Statik başlatıcıda lambda ile paralel akış neden kilitlenmeye neden oluyor?

Statik başlatıcıda bir lambda ile paralel akış kullanmanın, CPU kullanımı olmadan görünüşte sonsuza kadar sürdüğü garip bir durumla karşılaştım. İşte kod:

class Deadlock {
    static {
        IntStream.range(0, 10000).parallel().map(i -> i).count();
        System.out.println("done");
    }
    public static void main(final String[] args) {}
}

Bu, bu davranış için minimum yeniden üretim testi senaryosu gibi görünmektedir. Eğer ben:

• Statik başlatıcı yerine bloğu ana yönteme koyun,
• paralelleştirmeyi kaldırın veya
• lambdayı çıkarın,

kod anında tamamlanır. Bu davranışı kimse açıklayabilir mi? Bu bir hata mı yoksa bu kasıtlı mı?

OpenJDK 1.8.0_66-dahili sürümünü kullanıyorum.

Stuart Marks tarafından "Sorun Değil" olarak kapatılan çok benzer bir vakanın ( JDK-8143380 ) hata raporunu buldum :

Bu bir sınıf başlatma kilitlenmesidir. Test programının ana iş parçacığı, sınıf için devam eden başlatma bayrağını ayarlayan sınıf statik başlatıcısını yürütür; bu bayrak statik başlatıcı tamamlanıncaya kadar ayarlanmış olarak kalır. Statik başlatıcı, lambda ifadelerinin diğer evrelerde değerlendirilmesine neden olan paralel bir akışı yürütür. Bu iş parçacıkları, sınıfın başlatmayı tamamlamasını bekliyor. Ancak, paralel görevlerin tamamlanmasını beklerken ana iş parçacığı bloke edilir ve bu da kilitlenmeye neden olur.

Paralel akış mantığını sınıf statik başlatıcısının dışına taşımak için test programı değiştirilmelidir. Sorun Değil Olarak Kapanış.

Bununla ilgili başka bir hata raporu bulabildim ( JDK-8136753 ), ayrıca Stuart Marks tarafından "Sorun Değil" olarak kapatıldı:

Bu, Fruit numaralandırmasının statik başlatıcısının sınıf başlatma ile kötü bir şekilde etkileşime girmesi nedeniyle oluşan bir kilitlenmedir.

Sınıf başlatmayla ilgili ayrıntılar için Java Dil Belirtimi, bölüm 12.4.2'ye bakın.

http://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.4.2

Kısaca neler oluyor aşağıdaki gibidir.

1. Ana iş parçacığı Fruit sınıfına atıfta bulunur ve başlatma sürecini başlatır. Bu işlem devam eden başlatma bayrağını ayarlar ve ana iş parçacığı üzerinde statik başlatıcıyı çalıştırır.
2. Statik başlatıcı, başka bir iş parçacığında bazı kodları çalıştırır ve bitmesini bekler. Bu örnek paralel akışları kullanır, ancak bunun akışlarla hiçbir ilgisi yoktur. Kodu başka bir iş parçacığında herhangi bir şekilde çalıştırmak ve bu kodun bitmesini beklemek aynı etkiye sahip olacaktır.
3. Diğer iş parçacığındaki kod, başlatma devam eden bayrağını kontrol eden Fruit sınıfına başvurur. Bu, bayrak temizlenene kadar diğer iş parçacığının engellenmesine neden olur. (JLS 12.4.2'nin 2. adımına bakın.)
4. Ana iş parçacığı, diğer iş parçacığının sona ermesini beklerken engellenir, bu nedenle statik başlatıcı asla tamamlanmaz. Statik başlatıcı tamamlanıncaya kadar başlatma devam eden bayrağı temizlenmediğinden, iş parçacıkları kilitlenir.

Bu sorunu önlemek için, bir sınıfın statik başlatmasının, diğer iş parçacıklarının bu sınıfın tamamlanmış başlatmasını gerektiren kodu yürütmesine neden olmadan hızla tamamlandığından emin olun.

Sorun Değil Olarak Kapanış.

FindBugs'un bu durum için bir uyarı eklemek için açık bir sorunu olduğunu unutmayın .

DeadlockSınıfın kendisini referans alan diğer konuların nerede olduğunu merak edenler için , Java lambdaları sizin yazdığınız gibi davranır:

public class Deadlock {
    public static int lambda1(int i) {
        return i;
    }
    static {
        IntStream.range(0, 10000).parallel().map(new IntUnaryOperator() {
            @Override
            public int applyAsInt(int operand) {
                return lambda1(operand);
            }
        }).count();
        System.out.println("done");
    }
    public static void main(final String[] args) {}
}

Normal anonim sınıflarda kilitlenme olmaz:

public class Deadlock {
    static {
        IntStream.range(0, 10000).parallel().map(new IntUnaryOperator() {
            @Override
            public int applyAsInt(int operand) {
                return operand;
            }
        }).count();
        System.out.println("done");
    }
    public static void main(final String[] args) {}
}

Bu sorunun mükemmel bir açıklaması, 07 Nisan 2015 tarihli Andrei Pangin tarafından yapılmıştır. Burada bulunabilir , ancak Rusça olarak yazılmıştır (yine de kod örneklerini incelemenizi öneririm - bunlar uluslararasıdır). Genel sorun, sınıf başlatma sırasında bir kilitlenmedir.

İşte makaleden bazı alıntılar:

JLS'ye göre , her sınıfın başlatma sırasında yakalanan benzersiz bir başlatma kilidi vardır. Başlatma sırasında diğer iş parçacığı bu sınıfa erişmeye çalıştığında, başlatma tamamlanana kadar kilit üzerinde engellenecektir. Sınıflar eşzamanlı olarak başlatıldığında, bir kilitlenme elde etmek mümkündür.

Tam sayıların toplamını hesaplayan basit bir program yazdım, neyi yazdırmalı?

public class StreamSum {
    static final int SUM = IntStream.range(0, 100).parallel().reduce((n, m) -> n + m).getAsInt();

    public static void main(String[] args) {
        System.out.println(SUM);
    }
} 

Şimdi parallel()lambda'yı Integer::sumcall ile kaldırın veya değiştirin - ne değişecek?

Burada yine kilitlenme görüyoruz [makalede daha önce sınıf başlatıcılarında bazı kilitlenme örnekleri vardı]. parallel()Akış işlemleri nedeniyle ayrı bir iş parçacığı havuzunda çalışır. Bu evreler, sınıf private staticiçinde bir yöntem olarak bayt kodu ile yazılan lambda gövdesini çalıştırmaya çalışır StreamSum. Ancak bu yöntem, akımın tamamlanmasının sonuçlarını bekleyen sınıf statik başlatıcısı tamamlanmadan çalıştırılamaz.

Daha akıllara durgunluk veren şey: bu kod farklı ortamlarda farklı şekilde çalışır. Tek bir CPU makinesinde doğru şekilde çalışacak ve büyük olasılıkla çok CPU'lu bir makinede asılı kalacaktır. Bu fark, Fork-Join havuzu uygulamasından gelir. Parametreyi değiştirerek kendiniz doğrulayabilirsiniz-Djava.util.concurrent.ForkJoinPool.common.parallelism=N