Wickeln einer Reihe von asynchronen Aufrufen mit einer synchronen Methode mit einem Rückgabewert

Question

Mein aktueller Code verwendet Reihe von asynchronen Prozessen, die in Ergebnissen enden. Ich muss jede davon so umhüllen, dass auf jede von einer synchronen Methode mit dem Ergebnis als Rückgabewert zugegriffen wird. Ich möchte die Executor-Dienste dazu nutzen, um viele von ihnen gleichzeitig zu ermöglichen. Ich habe das Gefühl, dass Future für meine Implementierung relevant sein könnte, aber ich kann keinen guten Weg finden, dies zu erreichen.

Was ich habe jetzt:

public class DoAJob { 
    ResultObject result; 

    public void stepOne() { 
    // Passes self in for a callback 
    otherComponent.doStepOne(this); 
    } 

    // Called back by otherComponent once it has completed doStepOne 
    public void stepTwo(IntermediateData d) { 
    otherComponent.doStepTwo(this, d); 
    } 

    // Called back by otherComponent once it has completed doStepTwo 
    public void stepThree(ResultObject resultFromOtherComponent) { 
    result = resultFromOtherComponent; 
    //Done with process 
    } 
} 

Diese ziemlich gut intern gearbeitet hat, aber jetzt brauche ich, wie mein Prozess in eine synchrone Methode mit einem Rückgabewert zuzuordnen:

public ResultObject getResult(){ 
    // ??? What goes here ??? 
} 

Hat jemand Haben Sie eine gute Idee, wie Sie das elegant umsetzen können?

Answer 1

Ich habe etwas ähnliches mit der Guava-Bibliothek getan; diese Links können Sie in die richtige Richtung:

Is it possible to chain async calls using Guava?

https://code.google.com/p/guava-libraries/wiki/ListenableFutureExplained

Answer 2

I invokeAll(..) empfehlen. Es wird eine Reihe von Aufgaben an den Executor übergeben und blockiert, bis der letzte abgeschlossen ist (erfolgreich/mit Ausnahme). Es gibt dann eine Liste der abgeschlossenen Future-Objekte zurück, sodass Sie sie erneut durchlaufen und die Ergebnisse in ein einzelnes ResultObject zusammenführen können.

In Sie nur eine einzige Aufgabe in einer synchronen Weise ausführen möchten, können Sie das folgende verwenden:

executor.invokeAll(Collections.singleton(task)); 

--edit--

Jetzt denke ich, dass ich besser verstehen Ihre Bedürfnisse. Ich nehme an, dass Sie eine Möglichkeit benötigen, unabhängige Aufgabenfolgen zu übermitteln. Bitte werfen Sie einen Blick auf den Code, den ich in this answer veröffentlicht habe.

Answer 3

Wenn Sie eine asynchrone Operation (die einen Rückruf ausführt, wenn sie beendet ist) in eine synchrone/blockierende Operation umwandeln möchten, können Sie eine blockierende Warteschlange verwenden. Sie können dies bei Bedarf in ein Future-Objekt einfügen.

1. eine blockierende Warteschlange definieren, die nur ein Element halten kann:

   BlockingQueue<Result> blockingQueue = new ArrayBlockingQueue<Result>(1);

2. Starten Sie Ihren asynchronen Prozess (wird im Hintergrund ausgeführt werden), und schreiben Sie den Rückruf, dass, wenn es fertig ist, Es fügt sein Ergebnis der blockierenden Warteschlange hinzu.

3. In Ihrem Vordergrund/Anwendungs-Thread, haben sie() aus der Warteschlange nehmen, die blockiert, bis ein Element zur Verfügung steht: (Vordergrundthread Bedürfnisse etwas Ähnliches schrieb

   Result result = blockingQueue.take();

ich vor um eine asynchrone Antwort von einem Remote-Rechner zu blockieren.) Verwenden Sie etwas wie eine Zukunft, finden Sie Beispielcode here.

Answer 4

Wenn Sie Ihre Hände schmutzig machen, können Sie diese

ResultObject result; 

public void stepOne() 

    otherComponent.doStepOne(this); 

    synchronized(this) 
     while(result==null) this.wait(); 
    return result; 

public void stepThree(ResultObject resultFromOtherComponent) 

    result = resultFromOtherComponent; 

    synchronized(this) 
     this.notify(); 

tun Oder können Sie höhere Ebene Concurrency-Tools verwenden, wie Blocking, Semaphore, CountdownLatch, Phaser, etc etc.

Hinweis dass DoAJob nicht threadsicher ist - Probleme treten auf, wenn zwei Threads gleichzeitig stepOne aufrufen.