Java-Multithread-Designmuster für gleichzeitiges kollaboratives Producer-Consumer-Design

Zwei Threads, ein Produzent und ein Konsument

Nachfrageszenario

Zwei Threads, einer für die Produktion und einer für den Konsum. Der Produzent produziert einen und der Konsument verbraucht einen

Beteiligte Probleme

Synchronisierungsprobleme: So stellen Sie die Integrität derselben Ressource sicher, wenn mehrere Threads gleichzeitig darauf zugreifen. Häufig verwendete Synchronisationsmethoden sind Markierungs- oder Sperrmechanismen.

Die Methoden wait() / nofity() sind zwei Methoden der Basisklasse Object, was bedeutet, dass alle Java-Klassen über diese beiden Methoden verfügen , Wir können einen Synchronisationsmechanismus für jedes Objekt implementieren.

Wait()-Methode: Wenn der Puffer voll/leer ist, stoppt der Producer/Consumer-Thread seine eigene Ausführung, gibt die Sperre auf, versetzt sich in einen Wartezustand und ermöglicht die Ausführung anderer Threads.

Notify()-Methode: Wenn der Produzent/Konsumer ein Produkt aus dem Puffer legt/entnimmt, sendet er eine ausführbare Benachrichtigung an andere wartende Threads, gibt gleichzeitig die Sperre auf und versetzt sich in einen Wartezustand.

Code-Implementierung (insgesamt drei Klassen und eine Testklasse mit Hauptmethode)

　　Resource.java
　　/**
　　* Created by yuandl on 2016-10-11./**
　　* 资源
　　*/
　　public class Resource {
　　/*资源序号*/
　　private int number = 0;
　　/*资源标记*/
　　private boolean flag = false;
　　/**
　　* 生产资源
　　*/
　　public synchronized void create() {
　　if (flag) {//先判断标记是否已经生产了，如果已经生产，等待消费;
　　try {
　　wait();//让生产线程等待
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　}
　　number++;//生产一个
　　System.out.println(Thread.currentThread().getName() + "生产者------------" + number);
　　flag = true;//将资源标记为已经生产
　　notify();//唤醒在等待操作资源的线程(队列)
　　}
　　/**
　　* 消费资源
　　*/
　　public synchronized void destroy() {
　　if (!flag) {
　　try {
　　wait();
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　}
　　System.out.println(Thread.currentThread().getName() + "消费者****" + number);
　　flag = false;
　　notify();
　　}
　}

Producer.java

　　/**
　　* Created by yuandl on 2016-10-11.
　　*
　　/**
　　* 生产者
　　*/
　　public class Producer implements Runnable {
　　private Resource resource;
　　public Producer(Resource resource) {
　　this.resource = resource;
　　}
　　@Override
　　public void run() {
　　while (true) {
　　try {
　　Thread.sleep(10);
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　resource.create();
　　}
　　}
　　}

Consumer.java

　/**
　　* 消费者
　　*/
　　public class Consumer implements Runnable {
　　private Resource resource;
　　public Consumer(Resource resource) {
　　this.resource = resource;
　　}
　　@Override
　　public void run() {
　　while (true) {
　　try {
　　Thread.sleep(10);
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　resource.destroy();
　　}
　　}
　　}

ProducerConsumerTest.java

　　/**
　　* Created by yuandl on 2016-10-11.
　　*/
　　public class ProducerConsumerTest {
　　public static void main(String args[]) {
　　Resource resource = new Resource();
　　new Thread(new Producer(resource)).start();//生产者线程
　　new Thread(new Consumer(resource)).start();//消费者线程
　　}
　　}

Ergebnisse drucken

Thread-0生产者------------1
　Thread-1消费者****1
　　Thread-0生产者------------2
　　Thread-1消费者****2
　　Thread-0生产者------------3
　　Thread-1消费者****3
　　Thread-0生产者------------4
　　Thread-1消费者****4
　　Thread-0生产者------------5
　　Thread-1消费者****5
　　Thread-0生产者------------6
　　Thread-1消费者****6
　　Thread-0生产者------------7
　　Thread-1消费者****7
　　Thread-0生产者------------8
　　Thread-1消费者****8
　　Thread-0生产者------------9
　　Thread-1消费者****9
　　Thread-0生产者------------10
　　Thread-1消费者****10

Die oben gedruckten Ergebnisse zeigen, dass es keine Probleme gibt

Problem mit mehreren Threads, mehreren Produzenten und mehreren Verbrauchern

Nachfrageszenario

Vier Threads, zwei sind für die Produktion verantwortlich, zwei sind für den Konsum verantwortlich, der Produzent produziert einen, der Verbraucher konsumiert einen

Beteiligte Probleme

NotifyAll()-Methode: Wenn der Produzent/Konsumer ein Produkt aus dem Puffer legt/entnimmt, sendet er eine ausführbare Benachrichtigung an alle anderen wartenden Threads, gibt gleichzeitig die Sperre auf und versetzt sich in einen Wartezustand.

Testen Sie den Code erneut

　ProducerConsumerTest.java
　　/**
　　* Created by yuandl on 2016-10-11.
　　*/
　　public class ProducerConsumerTest {
　　public static void main(String args[]) {
　　Resource resource = new Resource();
　　new Thread(new Consumer(resource)).start();//生产者线程
　　new Thread(new Consumer(resource)).start();//生产者线程
　　new Thread(new Producer(resource)).start();//消费者线程
　　new Thread(new Producer(resource)).start();//消费者线程
　　}
　　}

Laufende Ergebnisse

　　Thread-0生产者------------100
　　Thread-3消费者****100
　　Thread-0生产者------------101
　　Thread-3消费者****101
　　Thread-2消费者****101
　　Thread-1生产者------------102
　　Thread-3消费者****102
　　Thread-0生产者------------103
　　Thread-2消费者****103
　　Thread-1生产者------------104
　　Thread-3消费者****104
　　Thread-1生产者------------105
　　Thread-0生产者------------106
　　Thread-2消费者****106
　　Thread-1生产者------------107
　　Thread-3消费者****107
　　Thread-0生产者------------108
　　Thread-2消费者****108
　　Thread-0生产者------------109
　　Thread-2消费者****109
　　Thread-1生产者------------110
　　Thread-3消费者****110

Finden Sie das Problem durch oben gedruckte Ergebnisse

101 Einmal produziert, zweimal konsumiert

105 Produziert, aber nicht konsumiert

Ursachenanalyse

Wann zwei Wann Zwei Threads betreiben gleichzeitig die Produzentenproduktion oder den Konsumentenverbrauch. Wenn ein Produzent oder zwei Threads warten (), benachrichtigen Sie (), da ein Thread die Markierung geändert hat und der andere Thread die Ausführung direkt fortsetzt das Fehlen eines Urteilszeichens.

Wenn die Beurteilung nur einmal erfolgt, führt dies dazu, dass Threads ausgeführt werden, die nicht ausgeführt werden sollten. Es ist ein Datenfehler aufgetreten.

Lösung

Die while-Beurteilungsmarkierung löst das Problem, ob der Thread ausgeführt werden möchte, nachdem er Ausführungsrechte erhalten hat, d. h. jedes Mal, wenn notify() nach wait() ausgeführt wird, wird die Markierung ausgeführt wird erneut beurteilt

Code-Verbesserungen (if->while in Resource)

Resource.java

　
　/**
　　* Created by yuandl on 2016-10-11./**
　　* 资源
　　*/
　　public class Resource {
　　/*资源序号*/
　　private int number = 0;
　　/*资源标记*/
　　private boolean flag = false;
　　/**
　　* 生产资源
　　*/
　　public synchronized void create() {
　　while (flag) {//先判断标记是否已经生产了，如果已经生产，等待消费;
　　try {
　　wait();//让生产线程等待
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　}
　　number++;//生产一个
　　System.out.println(Thread.currentThread().getName() + "生产者------------" + number);
　　flag = true;//将资源标记为已经生产
　　notify();//唤醒在等待操作资源的线程(队列)
　　}
　　/**
　　* 消费资源
　　*/
　　public synchronized void destroy() {
　　while (!flag) {
　　try {
　　wait();
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　}
　　System.out.println(Thread.currentThread().getName() + "消费者****" + number);
　　flag = false;
　　notify();
　　}
　　}

Das Problem wurde erneut gefunden

Beim Drucken auf einen bestimmten Wert, z. B. 74 nach der Produktion, bleibt das Programm hängen, als wäre es gesperrt.

Ursachenanalyse

Benachrichtigen: Kann nur einen Thread aufwecken. Wenn diese Party diese Party aufweckt, ist das bedeutungslos. Darüber hinaus führt die Benachrichtigung über die Beurteilungsmarke zu einem „Deadlock“.

Lösung

notifyAll löst das Problem, dass der eigene Thread den Thread der anderen Partei definitiv aufweckt.

Endgültige Codeverbesserungen (notify()->notifyAll() in Resource)

Resource.java

　/**
　　* Created by yuandl on 2016-10-11./**
　　* 资源
　　*/
　　public class Resource {
　　/*资源序号*/
　　private int number = 0;
　　/*资源标记*/
　　private boolean flag = false;
　　/**
　　* 生产资源
　　*/
　　public synchronized void create() {
　　while (flag) {//先判断标记是否已经生产了，如果已经生产，等待消费;
　　try {
　　wait();//让生产线程等待
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　}
　　number++;//生产一个
　　System.out.println(Thread.currentThread().getName() + "生产者------------" + number);
　　flag = true;//将资源标记为已经生产
　　notifyAll();//唤醒在等待操作资源的线程(队列)
　　}
　　/**
　　* 消费资源
　　*/
　　public synchronized void destroy() {
　　while (!flag) {
　　try {
　　wait();
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　}
　　System.out.println(Thread.currentThread().getName() + "消费者****" + number);
　　flag = false;
　　notifyAll();
　　}
　　}

Laufergebnisse

Thread-0生产者------------412
　　Thread-2消费者****412
　　Thread-0生产者------------413
　　Thread-3消费者****413
　　Thread-1生产者------------414
　　Thread-2消费者****414
　　Thread-1生产者------------415
　　Thread-2消费者****415
　　Thread-0生产者------------416
　　Thread-3消费者****416
　　Thread-1生产者------------417
　　Thread-3消费者****417
　　Thread-0生产者------------418
　　Thread-2消费者****418
　　Thread-0生产者------------419
　　Thread-3消费者****419
　　Thread-1生产者------------420
　　Thread-2消费者****420

Das obige wird ohne Probleme erledigt