Die Sperrschnittstelle bietet eine flexiblere Sperrsteuerung als synchronisiert, um den Versuchserwerb, die Unterbrechung, die Zeitlimitakquisition und das faire Sperre zu unterstützen. 2. Zustand erm?glicht eine genaue Kommunikation zwischen den Threads durch mehrere Zustandsvariablen, um Fehlwachen zu vermeiden. 3. Zu den gemeinsamen Synchronisatoren geh?rt Countdownlatch zum Warten auf mehrere Aufgaben, zyklische Barrier für die Multi-Thread-Synchronisation, um Barrierpunkte zu erreichen, Semaphor zur Steuerung der Anzahl der gleichzeitigen Threads und Phaser für die phasedige Synchronisation dynamischer Threads; Bei der Verwendung muss die Einfachheit der synchronisierten Priorit?t einger?umt werden. Die Sperre muss Try-final kombinieren, um Deadlocks zu verhindern, der Zustand sollte verwendet werden, und entsprechende Synchronisierungswerkzeuge sollten entsprechend der Szene ausgew?hlt werden, um eine übergeordnete Entscheidung zu vermeiden.

Bei der gleichzeitigen Programmierung von Java, obwohl synchronized Schlüsselw?rter einfach und einfach zu bedienen sind, sind sie in komplexeren Szenarien nicht flexibel genug. Zu diesem Zweck stellt Java das Paket java.util.concurrent.locks bereit, das leistungsst?rkere Tools für Parallelit?tskontrolle enth?lt: Sperren, Bedingungen und Synchronisatoren . Sie erm?glichen es Entwicklern, das Verhalten des Fadensynchronisationsverhaltens k?rniger zu steuern.

1. Verriegelungsschnittstelle: Ein flexiblerer Sperrmechanismus als synchronisiert

Lock ist eine verbesserte Alternative zu synchronized , wobei die Hauptvorteile sind:

• Sie k?nnen versuchen, das Schloss ( tryLock() ) zu erwerben, um Blockierung zu vermeiden
• Kann das Warten auf Sperre unterbrechen
• Kann Zeitüberschreitung, um das Schloss zu erwerben
• Weitere feinere Sperrkontrolle (z. B. Lesen und Schreiben von Trennung)

Gemeinsame Implementierungsklassen: ReentrantLock

 Lock Lock = New Reentrantlock ();

lock.lock ();
versuchen {
    // Critical Area System.out.println ("Thread tritt kritisch");
} Endlich {
    lock.unlock (); // muss endlich platziert werden, um Deadlock zu verhindern}

?? HINWEIS: Das Schloss muss manuell ver?ffentlicht werden, andernfalls verursacht es Deadlock oder Ressourcenleckage.

Vergleich mit synchronisiert

2. Zustand: Genauige Kontrolle der Kommunikation zwischen den Threads

Condition ?hnelt dem Object wait() und notify() , ist jedoch flexibler. Eine Lock kann mehrere Condition erstellen, um mehrere Warten/Benachrichtigungen zu implementieren.

Verwenden Sie das Szenario: Produzent-Verbrauchermodell

 Lock Lock = New Reentrantlock ();
Bedingung Notfull = lock.newCondition ();
Bedingung Notizty = lock.newcondition ();

// Produzent lock.lock ();
versuchen {
    while (queue.size () == Kapazit?t) {
        Notfull.aait (); // Wartewarteschlange ist unzufrieden}
    queue.add (item);
    notieren.Signal (); // den Verbraucher benachrichtigen} endlich {
    lock.unlock ();
}

// Consumer lock.lock ();
versuchen {
    while (queue.isempty ()) {
        notieren.await (); // Warte Warteschlange nicht leer}
    String item = queue.poll ();
    Notfurl.Signal (); // den Produzenten} endlich {benachrichtigen {
    lock.unlock ();
}

? Vorteile: Mehrere Bedingungsvariablen k?nnen unabh?ngig gesteuert werden, um falsche Aufwachen oder Benachrichtigungsst?rungen zu vermeiden.

3. H?ufige Synchronisatoren: Erweiterte Synchronisationstools, die von JUC zur Verfügung gestellt werden

Java bietet mehrere Out-of-the-Box-Synchronisierungs-Helferklassen im java.util.concurrent -Paket:

① Countdownlatch: Countdown -Verriegelung

Wird verwendet, damit ein oder mehrere Threads darauf warten, dass andere Threads die Vorg?nge abschlie?en.

 Countdownlatch Latch = new Countdownlatch (3);

// Worker Thread Latch.countdown ();

// Warten Sie auf Thread Latch.await (); // Blockieren, bis die Anzahl auf Null zurückkehrt

? Anwendbares Szenario: Der Haupt -Thread wartet, bis mehrere Hintergrundaufgaben ausgeführt werden.

② Cyclicbarrier: kreisf?rmiger Zaun

Lassen Sie eine Gruppe von F?den aufeinander warten, bis sie alle einen bestimmten Barrierpunkt erreichen, und führen dann weiter zusammen.

 Cyclicbarrier Barriere = New Cyclicbarrier (3, () -> {
    System.out.println ("Alle Threads sind vorhanden, starten Sie Aktion!");
});

Barriere.aait (); // Warten Sie, nachdem jeder Thread aufgerufen wurde

? Anwendbare Szenarien: Multi-Thread-Parallel-Computing wird in Stufen synchronisiert, wie z. B. parallele Testdatenvorbereitung.

③ Semaphor: Semaphor, kontrollieren Sie die Anzahl der gleichzeitigen gleichzeitigen

Begrenzt die Anzahl der Threads, die gleichzeitig auf eine Ressource zugreifen (z. B. Datenbankverbindungspool).

 Semaphore Semaphore = New Semaphor (3); // bis zu 3 Threads Zugriff auf semaphore.acquire (); // Erhalten Sie Erlaubnisversuch {
    // eingeschr?nkte Operationen durchführen} endlich {
    semaphore.release (); // die Lizenz ver?ffentlichen}

? Anwendbare Szenarien: Aktuelle Begrenzung, Ressourcenpool -Steuerung.

④ Phaser: Flexiblere Synchronisationsbarriere (Fortgeschrittene)

Es unterstützt die dynamische Registrierung der teilnehmenden Threads, die für Szenarien geeignet sind, in denen Phasenaufgaben und die Anzahl der Threads nicht festgelegt sind.

Vorschl?ge und Vorsichtsma?nahmen für den Gebrauch

• Priorit?t zu verwenden synchronisiert : Wenn die Szene einfach ist, ist synchronized und einfacher.
• Die Sperre muss mit Try-final ausgestattet sein : Verhindern Sie, dass Ausnahmen ver?ffentlichen, dass das Schloss unver?ffentlicht ist.
• Vermeiden Sie verschachtelte Schl?sser : Es ist leicht, Deadlocks zu verursachen. Wenn Sie sie verwenden müssen, achten Sie auf die Verriegelungsbestellung.
• Die Bedingung muss in Verbindung mit dem Urteil verwendet werden : Verhindern Sie falsches Erwachen.
• Synchronisatoren sind nicht allgegenw?rtig : W?hlen Sie die richtigen Werkzeuge aus und vermeiden Sie eine überbearbeitung.

Grunds?tzlich ist das. Die Parallelit?tstools von Java bieten eine breite Palette von Optionen, von der zugrunde liegenden Lock bis zu den hochrangigen Synchronizers . Der Schlüssel besteht darin, die anwendbaren Szenarien jedes Mechanismus zu verstehen und "bereit zu verwenden, aber f?lschlicherweise zu verwenden".

Das obige ist der detaillierte Inhalt vonJava Parallelit?t: Schl?sser, Bedingungen und Synchronisatoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!