Zusammenfassung von "In Java gelernten Entwurfsmustern (Multithread Edition)" (Teil 5)

Geschütztes Aufhängungsmuster

Das Guarded Suspension-Muster enthält Namen wie ** Guarded Wait ** und ** Spin Lock **.

Request.java

public class Request {
     private final String name;
     public Request(String name) {
         this.name = name;
     }
     public String getName() {
         return name;
     }
     public String toString() {
         return "[ Request " + name + " ]";
     }
}

RequestQueue.java

import java.util.Queue;
import java.util.LinkedList;

public class RequestQueue {
    private final Queue<Request> queue = new LinkedList<Request>();
    public synchronized Request getRequest() {
        while (queue.peek() == null) {
            try {
                wait(); //Warten Sie, wenn die Warteschlange leer ist(Geben Sie das eingestellte Gewicht ein)
            } catch (InterruptedException e) {
            }
        }
        return queue.remove();
    }
    public synchronized void putRequest(Request request) {
        queue.offer(request);
        notifyAll(); //Benachrichtigen Sie den wartenden Thread, dass eine Anforderung in die Warteschlange gestellt wurde
    }
}

ClientThread.java

import java.lang.Math;

public class ClientThread extends Thread {
    private final RequestQueue requestQueue;
    public ClientThread(RequestQueue requestQueue, String name) {
        super(name);
        this.requestQueue = requestQueue;
    }
    public void run() {
        for (int i = 0; i <= 100; i++) {
            Request request = new Request("No." + i);
            System.out.println(Thread.currentThread().getName() + " put " + request);
            requestQueue.putRequest(request);
            try {
                Thread.sleep((int)(Math.random()*10));
            } catch (InterruptedException e) {
            }
        }
    }
}

ServerThread.java

import java.lang.Math; 
 
public class ServerThread extends Thread { 
    private final RequestQueue requestQueue; 
    public ServerThread(RequestQueue requestQueue, String name) { 
        super(name); 
        this.requestQueue = requestQueue; 
    } 
    public void run() { 
        for (int i = 0; i <= 100; i++) { 
            Request request = requestQueue.getRequest(); 
            System.out.println(Thread.currentThread().getName() + " get " + request); 
            try { 
                Thread.sleep((int)(Math.random()*10)); 
            } catch (InterruptedException e) { 
            } 
        } 
    } 
}

Main.java

public class Main { 
    public static void main(String[] args) { 
        RequestQueue requestQueue = new RequestQueue(); 
        new ClientThread(requestQueue, "A").start(); 
        new ServerThread(requestQueue, "B").start(); 
    } 
}

Ausführungsergebnis

...
A put [ Request No.95 ]
B get [ Request No.91 ]
B get [ Request No.92 ]
A put [ Request No.96 ]
A put [ Request No.97 ]
B get [ Request No.93 ]
A put [ Request No.98 ]
B get [ Request No.94 ]
A put [ Request No.99 ]
B get [ Request No.95 ]
B get [ Request No.96 ]
B get [ Request No.97 ]
B get [ Request No.98 ]
B get [ Request No.99 ]
...

ClientThread übergibt eine Instanz der Anforderung an SeverThread. Dies ist eine sehr einfache ** Kommunikation zwischen Threads **. ClientThread und ServerThread heißen ** aktive Objekte ** und RequestQueue heißt ** passive Objekte **.

ClientThread sendet eine Anfrage an Queue (put) und ServerThread ruft eine Anfrage aus Queue (get) ab. put and get sind synchronisiert und exklusiv.

Die Methode getReques ruft eine der ältesten Anforderungen ab. Wenn keine Anforderungen vorhanden sind, warten Sie, bis ein anderer Thread eine putRequest erstellt. Die Bedingung queue.peek ()! = Null, dh die Bedingung, dass die Warteschlange nicht leer ist, muss erfüllt sein. Eine solche Bedingung, die erfüllt sein muss, wird als ** Schutzbedingung ** des Guarded Suspension-Musters bezeichnet.

Die putRequest-Methode fügt eine Anforderung hinzu. Benachrichtigen Sie dann den wartenden Thread mit notifyAll.

Warten und benachrichtigen Zusammenfassung der in Java-Sprache erlernten Entwurfsmuster (Multithreaded Edition) "(Teil 1) Sehen.

Wie das Ausführungsergebnis zeigt, überholt B (get) A (put) nicht.

Charakter

Die GuardedObject-Rolle ist eine Klasse mit einer geschützten Methode. Wenn die Schutzbedingung erfüllt ist, wird sie sofort ausgeführt, und wenn sie nicht erfüllt ist, wird sie warten gelassen. Die GuardedObjec-Rolle verfügt möglicherweise über eine stateChangingMethod, die den Status der Instanz ändert. Im Beispielprogramm spielt die RequestQueue-Klasse diese Rolle, getRequest entspricht guardedMethod und putRequest entspricht stateChangingMethod.

Beziehung Zusammenfassung der in Java-Sprache erlernten Entwurfsmuster (Multithreaded Edition) "(Teil 1) Zusammenfassung der in Java-Sprache erlernten Entwurfsmuster (Multithreaded Edition) "(Teil 2) Zusammenfassung der in Java-Sprache erlernten Entwurfsmuster (Multi-Thread-Edition) "(Teil 3) Zusammenfassung der in Java-Sprache erlernten Entwurfsmuster (Multi-Thread-Edition) "(Teil 4)