Warum verursacht ein paralleler Stream mit Lambda im statischen Initialisierer einen Deadlock?

Ich bin auf eine seltsame Situation gestoßen, in der die Verwendung eines parallelen Streams mit einem Lambda in einem statischen Initialisierer scheinbar ohne CPU-Auslastung ewig dauert. Hier ist der Code:

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

Dies scheint ein minimaler Reproduktionstestfall für dieses Verhalten zu sein. Wenn ich:

• Setzen Sie den Block in die Hauptmethode anstelle eines statischen Initialisierers.
• Parallelisierung entfernen oder
• Entfernen Sie das Lambda,

Der Code wird sofort vervollständigt. Kann jemand dieses Verhalten erklären? Ist es ein Fehler oder ist das beabsichtigt?

Ich verwende OpenJDK Version 1.8.0_66-intern.

Ich habe einen Fehlerbericht eines sehr ähnlichen Falls ( JDK-8143380 ) gefunden, der von Stuart Marks als "Not a Issue" geschlossen wurde:

Dies ist ein Deadlock für die Klasseninitialisierung. Der Hauptthread des Testprogramms führt den statischen Klasseninitialisierer aus, der das Flag für die laufende Initialisierung für die Klasse setzt. Dieses Flag bleibt gesetzt, bis der statische Initialisierer abgeschlossen ist. Der statische Initialisierer führt einen parallelen Stream aus, wodurch Lambda-Ausdrücke in anderen Threads ausgewertet werden. Diese Threads blockieren das Warten, bis die Klasse die Initialisierung abgeschlossen hat. Der Hauptthread wird jedoch blockiert, bis die parallelen Aufgaben abgeschlossen sind, was zu einem Deadlock führt.

Das Testprogramm sollte geändert werden, um die Parallelstromlogik außerhalb des statischen Klasseninitialisierers zu verschieben. Schließen als kein Problem.

Ich konnte einen weiteren Fehlerbericht darüber finden ( JDK-8136753 ), der von Stuart Marks ebenfalls als "Not an Issue" geschlossen wurde:

Dies ist ein Deadlock, der auftritt, weil der statische Initialisierer der Fruit-Enumeration schlecht mit der Klasseninitialisierung interagiert.

Weitere Informationen zur Klasseninitialisierung finden Sie in der Java-Sprachspezifikation, Abschnitt 12.4.2.

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

Kurz gesagt, was passiert, ist wie folgt.

1. Der Hauptthread verweist auf die Fruit-Klasse und startet den Initialisierungsprozess. Dadurch wird das Flag für die laufende Initialisierung gesetzt und der statische Initialisierer auf dem Hauptthread ausgeführt.
2. Der statische Initialisierer führt Code in einem anderen Thread aus und wartet, bis er abgeschlossen ist. In diesem Beispiel werden parallele Streams verwendet, dies hat jedoch nichts mit Streams an sich zu tun. Das Ausführen von Code in einem anderen Thread auf irgendeine Weise und das Warten auf das Beenden dieses Codes hat den gleichen Effekt.
3. Der Code im anderen Thread verweist auf die Fruit-Klasse, die das Flag für die laufende Initialisierung überprüft. Dadurch wird der andere Thread blockiert, bis das Flag gelöscht wird. (Siehe Schritt 2 von JLS 12.4.2.)
4. Der Hauptthread wird blockiert und wartet darauf, dass der andere Thread beendet wird, sodass der statische Initialisierer nie abgeschlossen wird. Da das Flag für die laufende Initialisierung erst nach Abschluss des statischen Initialisierers gelöscht wird, sind die Threads blockiert.

Um dieses Problem zu vermeiden, stellen Sie sicher, dass die statische Initialisierung einer Klasse schnell abgeschlossen wird, ohne dass andere Threads Code ausführen, für den diese Klasse die Initialisierung abgeschlossen haben muss.

Schließen als kein Problem.

Beachten Sie, dass FindBugs ein offenes Problem beim Hinzufügen einer Warnung für diese Situation hat.

Für diejenigen, die sich fragen, wo sich die anderen Threads befinden, die auf die DeadlockKlasse selbst verweisen , verhalten sich Java-Lambdas so, wie Sie dies geschrieben haben:

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) {}
}

Bei regulären anonymen Klassen gibt es keinen Deadlock:

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) {}
}

Es gibt eine ausgezeichnete Erklärung für dieses Problem von Andrei Pangin vom 07. April 2015. Es ist hier verfügbar , aber in russischer Sprache verfasst (ich empfehle, Codebeispiele trotzdem zu überprüfen - sie sind international). Das allgemeine Problem ist eine Sperre während der Klasseninitialisierung.

Hier sind einige Zitate aus dem Artikel:

Laut JLS verfügt jede Klasse über eine eindeutige Initialisierungssperre , die während der Initialisierung erfasst wird. Wenn ein anderer Thread während der Initialisierung versucht, auf diese Klasse zuzugreifen, wird sie für die Sperre blockiert, bis die Initialisierung abgeschlossen ist. Wenn Klassen gleichzeitig initialisiert werden, kann es zu einem Deadlock kommen.

Ich habe ein einfaches Programm geschrieben, das die Summe der ganzen Zahlen berechnet. Was soll es drucken?

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);
    }
} 

Entfernen parallel()oder ersetzen Sie nun Lambda durchInteger::sum Call - was wird sich ändern?

Hier sehen wir wieder einen Deadlock [es gab einige Beispiele für Deadlocks in Klasseninitialisierern zuvor im Artikel]. Aufgrund der parallel()Stream-Operationen werden in einem separaten Thread-Pool ausgeführt. Diese Threads versuchen, den Lambda-Body auszuführen, der als private staticMethode innerhalb der StreamSumKlasse in Bytecode geschrieben ist . Diese Methode kann jedoch nicht vor Abschluss des statischen Klasseninitialisierers ausgeführt werden, der auf die Ergebnisse der Stream-Fertigstellung wartet.

Was noch umwerfender ist: Dieser Code funktioniert in verschiedenen Umgebungen unterschiedlich. Es funktioniert ordnungsgemäß auf einem einzelnen CPU-Computer und hängt höchstwahrscheinlich auf einem Multi-CPU-Computer. Dieser Unterschied ergibt sich aus der Implementierung des Fork-Join-Pools. Sie können dies selbst überprüfen, indem Sie den Parameter ändern-Djava.util.concurrent.ForkJoinPool.common.parallelism=N