Threads Listener für Future finish

[KuhTee]

Hallo,


ich habe eine Library, welche diverse asynchron laufende Methoden zur Verfügung stellt. Diese Methoden liefern mir ein Future Objekt zurück. Das ist prinzipiell sehr gut, aber nun habe ich gemerkt, dass es offenbar keinen FutureListener (oder ähnliches) gibt? Offenbar gibt es nur zwei blockierende (!) get() Methoden, deren Verwendung auch im Beispiel in der Future Beschreibung drinsteht. Nun habe ich also eine asynchron laufende Funktion, aber am Ende warte ich doch wieder blockierend. Keine Ahnung, wer bei Sun/Oracle da zuviel Gras geraucht hat, aber sehr durchdacht scheint mir das nicht.
Gibt es da eine empfohlene Lösung? Evtl eine, die über einen weiteren Thread, welcher ständig auf das Future pollt, hinaus geht?
Beim googlen habe ich diverse Vorschläge gefunden wie das Erben von ThreadPoolExecuter und allerlei andere Vorschläge, die mir aber nicht wirklich weiterhelfen. Mehr als das Future was ich zurückbekomme habe ich wie gesagt nicht.


Danke.

 

[mohrenkopf]

Wenn du wirklich nicht mehr hast als die Futures und auch der ExecutorService.submit(...) Kram gekapselt ist, hast du wohl wenig Möglichkeiten.

So was ähnliches habe ich mal gemacht, habe es ein wenig angepasst, vielleicht kommst du damit weiter.

Gruß mohrenkopf

/*
 * Demo FutureListener
 * (c) mohrenkopf
 */
package DemoFutureListener;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


//Demo-Library
class Library
{
    static public Future doSomething() {return null;}
}


interface FutureListener
{
    public void onTaskIsDone( Future f );
}


class FutureDispatcher implements Runnable
{
    ScheduledExecutorService scheduler;
    Map<Future, FutureListener> map = new HashMap<Future, FutureListener>();

    public FutureDispatcher()
    {
        //Jede Sekunde alle Futures auf .isDone() ckecken
        scheduler.scheduleAtFixedRate( this, 0, 1, TimeUnit.SECONDS );
    }

    public void handleWhenDone( Future f, FutureListener listenerToCallWhenDone )
    {
        map.put( f, listenerToCallWhenDone );
    }

    @Override
    public void run()
    {
        for ( Future f : map.keySet() )
        {
            //TODO: Thread-sicher machen!
            if ( f.isDone() )
            {
                map.get( f ).onTaskIsDone( f );
                map.remove( f );
            }
        }
    }
}

public class Test
{

    public static void main( String[] args ) throws Exception
    {
        FutureDispatcher handler = new FutureDispatcher();

        FutureListener listener = new FutureListener()
        {

            @Override
            public void onTaskIsDone( Future f )
            {
                System.out.println( "Darauf habe ich gewartet" );
            }
        };


        Future f = Library.doSomething();

        //Ruft den Listener auf, sowie Future fertig ist.
        handler.handleWhenDone( f, listener );

    }
}

 

[KuhTee]

Hm... ja, so ähnlich hab ich mir das auch gedacht. Aber danke 🙂