1. Die Verwendung von Blockingqueue ist die direkteste und empfohlenste M?glichkeit, das Java-Produzenten-Consumer-Modell zu implementieren. Es behandelt die Fadensynchronisation intern. Der Produzent ruft die Put () -Methode auf, um den Warteschlangenraum zu blockieren, und der Verbraucher ruft die Methode take () auf, um Wartedaten zu blockieren. 2. Wenn für die manuelle Implementierung das synchronisierte Sperren und Warten-/Benachrichtigungsmechanismus erforderlich ist, um das Gewindeverhalten zu koordinieren, besteht der Kern darin, die Bedingungen zu überprüfen und den gemeinsam genutzten Puffer innerhalb des Synchronisationsblocks zu betreiben. 3. Die Hinweise umfassen die korrekte Handhabung von Interrupts, die Multi-Thread-Weckstrategie zur Auswahl von NotifyAll (), das Festlegen einer angemessenen Puffergr??e und das elegant schlie?ende Threads.

In der Java-Multithread-Programmierung ist die Implementierung des Produzenten-Verbrauchermodells ein gemeinsames Parallelit?tsmodell. Es wird haupts?chlich verwendet, um das Problem der Zusammenarbeit zwischen mehreren Threads zu l?sen: Ein oder mehrere Threads sind für die "Produktion" von Daten verantwortlich, und ein anderes oder mehr Threads sind für das "Konsum" dieser Daten verantwortlich.

Um dieses Modell zu implementieren, ist der Schlüssel, wie Sie Daten sicher zwischen Threads übergeben und Ressourcenwettbewerbe und Deadlockprobleme vermeiden k?nnen. Beginnen wir mit mehreren praktischen Perspektiven und sprechen wir darüber, wie es im Detail geht.

Die Verwendung BlockingQueue ist der direkteste Weg

Java bietet bereitgestellte BlockingQueue -Schnittstellen (wie ArrayBlockingQueue oder LinkedBlockingQueue ), das interne Probleme mit der Synchronisierung von Threads behandelt hat und die am meisten empfohlene Methode zur Implementierung von Produzentenkonsumenten ist.

Es ist sehr einfach zu verwenden:

• Der Produzent ruft put() -Methode auf, um Daten in die Warteschlange zu setzen
• Der Verbraucher ruft take() auf, um Daten aus der Warteschlange abzurufen

Beide Methoden blockieren, und wenn die Warteschlange voll ist, wird der Produzent warten. Wenn die Warteschlange leer ist, wartet der Verbraucher genau wie unser gewünschtes Verhalten.

Beispielcode -Snippet:

 BlockingQueue <Ganzzahl> queue = new ArrayBlockingQueue <> (10);

// Produzenten -Thread neuer Thread (() -> {
    versuchen {
        int i = 0;
        while (wahr) {
            Queue.put (i);
            System.out.println ("produziert:" i);
        }
    } catch (InterruptedException e) {
        Thread.currentThread (). Interrupt ();
    }
}).Start();

// Verbraucher -Thread neuer Thread (() -> {
    versuchen {
        while (wahr) {
            int value = queue.take ();
            System.out.println ("konsumiert:" Wert);
        }
    } catch (InterruptedException e) {
        Thread.currentThread (). Interrupt ();
    }
}).Start();

Wenn Sie die vorgefertigte Warteschlange nicht verwenden, k?nnen Sie die Lock-Steuerung manuell hinzufügen

Wenn Sie sich nicht auf BlockingQueue verlassen m?chten, k?nnen Sie die Logik auch manuell implementieren. Zu diesem Zeitpunkt müssen synchronized Schlüsselw?rter und wait/notify verwendet werden, um das Thread -Verhalten zu koordinieren.

Kernidee:

• Verwenden Sie eine gemeinsam genutzte Datenstruktur (z. B. List ) als Puffer
• Sperren beim Betrieb des Puffer
• Wenn der Puffer voll ist, wartet der Produzentfaden; wacht auf, wenn Platz vorhanden ist
• Wenn der Puffer leer ist, wartet der Verbraucherfaden. Weckt auf, wenn neue Daten verfügbar sind

Anmerkungen:

• Die Bedingungen müssen in der Schleife überprüft werden, da m?glicherweise falsche Aufwachen vorliegen
• wait() und notify() aufrufen müssen im Synchronisationsblock erfolgen

Beispiel Pseudocode:

 ?ffentliche Klasse SharedBuffer {
    private list <GanzEger> buffer = new ArrayList <> ();
    private endgültige int max_size = 10;

    public synchronisierte void put (int value) l?st unterrupte Ausnahme {
        while (buffer.size () == max_size) {
            Warten();
        }
        buffer.add (Wert);
        notifyAll ();
    }

    public synchronisierte int take () l?scht InterruptedException {
        while (buffer.isempty ()) {
            Warten();
        }
        int value = buffer.remove (0);
        notifyAll ();
        Rückgabewert;
    }
}

Ein paar leicht zu ignorierende, aber wichtige Details

• Interrupt -Handhabung : Der Faden kann unterbrochen werden. Denken Sie daran, InterruptedException zu erfassen und den Interrupt -Zustand wiederherzustellen.
• Weckstrategie in Multi-Producer-/Verbraucher-Szenarien : Wenn viele Themen warten, versuchen Sie, notifyAll() anstelle von notify() zu verwenden, um das fehlende Aufwachen zu vermeiden
• Setzen Sie eine angemessene Puffergr??e : Zu gro? wird der Speicher verschwendet, zu klein kann zu h?ufigem Warten führen
• Elegant enge Threads : Der Schleifenausgang kann gesteuert werden, indem Flag -Bits anstelle von unendlichen Schleifen hinzugefügt werden, die keine Ausgangsbedingungen behandeln

Grunds?tzlich ist das. BlockingQueue kann Funktionen schnell implementieren, w?hrend die manuelle Implementierung Ihnen helfen kann, den zugrunde liegenden Mechanismus zu verstehen. Die beiden Methoden haben ihre eigenen anwendbaren Szenarien. Durch die Auswahl des richtigen Tools k?nnen Sie ein stabiles und effizientes gleichzeitiges Programm schreiben.

Das obige ist der detaillierte Inhalt vonImplementierung des Produzenten-Verbraucher-Musters mit Java-Threads.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!