Zukünftiges Muster

Angenommen, Sie haben eine Methode, die lange dauert, um das Ausführungsergebnis zu erhalten. ** Holen Sie sich einen Gutschein, anstatt auf das Ausführungsergebnis zu warten **. Es dauert nicht lange, einen Gutschein zu erhalten. Der Gutschein wird zu diesem Zeitpunkt als Zukunftsrolle bezeichnet. Der Thread, der den Gutschein erhalten hat, verwendet später die Future-Rolle, um das Ausführungsergebnis zu erhalten. Wenn das Ausführungsergebnis verfügbar ist, erhalten Sie es sofort und wenn nicht, warten Sie, bis Sie können.

(Den gesamten Code finden Sie in diesem Handbuch.)

`Main.java`


public class Main { 
    public static void main(String[] args) { 
        ...
        Host host = new Host(); 
        Data data1 = host.request(10, 'A'); 
        Data data2 = host.request(20, 'B'); 
        Data data3 = host.request(30, 'C'); 

        try { 
            Thread.sleep(2000); 
        } catch (InterruptedException e) { 
        } 
 
        System.out.println("data1 = " + data1.getContent()); 
        System.out.println("data2 = " + data2.getContent()); 
        System.out.println("data3 = " + data3.getContent()); 
    } 
}

`Host.java`


public class Host { 
    public Data request(final int count, final char c) { 
        final FutureData future = new FutureData();  //Erstellen Sie einen Gutschein

        new Thread() { 
            public void run() { 
                RealData realdata = new RealData(count, c); 
                future.setRealData(realdata); 
            } 
        }.start(); 

        return future;  //Gutschein zurücksenden
    } 
}

`Data.java`


public interface Data { 
    public abstract String getContent(); 
}

`Future.java`


public class FutureData implements Data { 
    private RealData realdata = null; 
    private boolean ready = false; 
    public synchronized void setRealData(RealData realdata) { 
        if (ready) { 
            return;     // balk 
        } 
        this.realdata = realdata; 
        this.ready = true; 
        notifyAll(); 
    } 
    public synchronized String getContent() { 
        while (!ready) { 
            try { 
                wait(); 
            } catch (InterruptedException e) { 
            } 
        } 
        return realdata.getContent(); 
    } 
}

Die Host-Klasse erstellt zuerst eine Instanz von FutureData. Diese Instanz ist der Rückgabewert. Starten Sie dann einen neuen Thread und erstellen Sie eine Instanz von RealData darin. Das Erstellen einer Instanz von RealData dauert einige Zeit. Rufen Sie nach dem Erstellen der Instanz die setRealData-Methode auf, um sie in der FutureData-Instanz festzulegen.

Die FureData-Klasse ist eine Gutscheinklasse. Das Feld realData ist ein Feld, das eine Instanz von RealData enthält, die erstellt wird. Dieses Feld wird von der setRealData-Methode zugewiesen. Die getContent-Methode ist eine Methode zum Abrufen der tatsächlichen Daten. Warten Sie, bis die Realdaten von setRealData festgelegt wurden. Wenn es gesetzt ist, kehrt es sofort zurück und wenn es nicht gesetzt ist, wartet es. Wartende Threads werden durch den Aufruf von notifyAll in setRealData geweckt.

Charakter

Kundenrolle Die Client-Rolle stellt eine Anforderung an die Host-Rolle und erhält als Ergebnis sofort die VirtualData-Rolle (Rückgabewert). Die hier empfangene VirtualData-Rolle ist eigentlich die Future-Rolle. Die Client-Rolle muss nicht wissen, ob der Rückgabewert eine RealData-Rolle oder eine Future-Rolle ist. Im Beispielprogramm spielte die Hauptklasse diese Rolle.

Host-Rolle Die Host-Rolle erstellt einen neuen Thread und beginnt mit der Erstellung der RealData-Rolle. Andererseits gibt die Rolle des Clients die Rolle der Zukunft als die Rolle der virtuellen Daten zurück. Im Beispielprogramm spielte die Host-Klasse diese Rolle.

Rolle für virtuelle Daten Die VirtualData-Rolle ist eine Rolle, die die Future-Rolle mit der RealData-Rolle gleichsetzt. Im Beispielprogramm spielte die Datenschnittstelle diese Rolle.

Real Data Rolle Die RealData-Rolle ist eine Rolle, die tatsächliche Daten darstellt. Das Erstellen dieses Objekts dauert einige Zeit. Im Beispielprogramm spielte die RealData-Klasse diese Rolle.

Zukünftige Rolle Die Future-Rolle ist eine Rolle, die von der Host-Rolle an die Client-Rolle als Gutschein für die RealData-Rolle übergeben wird. Die Future-Rolle verhält sich als Virtual Data-Rolle für die Client-Rolle. Bei der Bedienung über die Client-Rolle wartet der Thread mit Wartezeit, bis die RealData-Rolle abgeschlossen ist. Im Beispielprogramm spielte die FureData-Klasse diese Rolle.

Tipps zur Erweiterung Ihrer Gedanken

Die Rolle der Zukunft, die nicht warten kann Es ist auch möglich, die Methode getContent asynchron zu implementieren. Anstelle der verwirrenden Geschichte, einen neuen Thread in der getContent-Methode zu erstellen, können Sie das Balking-Muster verwenden, um "nach Hause zu gehen, wenn Sie nicht können".

Rückruf und Zukunftsmuster Wenn Sie auf den Abschluss der Verarbeitung warten und den Rückgabewert erhalten möchten, können Sie sich eine Methode namens ** Rückruf ** vorstellen. Callback ist eine Methode, bei der der von der Host-Rolle nach Abschluss der Verarbeitung gestartete Thread die Methode der Client-Rolle zurückruft.

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

Zukünftiges Muster

Main.java

Host.java

Data.java