Frage bzgl ExecturoService

[bygones]

Hi,

ich habe folgendes Szenario:

Ich will eine Reihe von asychronen Thread starten lassen und die Ergebnisse nach max. X sekunden holen (wenn frueher da sind, dann natuerlich frueher). Sind alle Threads beendet (sei es weil sie durch gelaufen sind oder wegen timeout), dann geht das Programm normal weiter.

Ich hab ein bisschen rumgesucht und bin dabei auf ExecutorService und Callable gestossen - da ich noch nicht viel erfahrung da habe - also im sinne von gar keiner - wollte ich mal nachfragen ob das dafuer verwendbar ist und / oder obs etwas besser passendes gibt

public class Test() {
 private static final int TIMEOUT = 5;
 
 public static void main(String[] args) {
   Callable<String> c1 =  createCallable(); // also irgendein Callable erzeugen
   Callable<String> c2 = createCallable(); // und noch eins
   
   ExecutorService executor = Executors.newCachedThreadPool(); // oder auch fixed pool
   Future res1 = executor.submit(c1);
   Future res2 = executor.submit(c2);

   String result1 = res1.get(TIMEOUT, TimeUnit.SECONDS);
   String result2 = res2.get(TIMEOUT, TimeUnit.SECONDS);

  // und irgendwie weiter
 }
}

ich hab mal das exception handling weggelassen...

was mich ein bisschen stoert ist, dass ich somit nicht auf jeden Thread X Sekunde warte, sondern wenn der 1. Thread z.b. nach 5sec nichts liefert, wird der 2. abgefragt - auch 5sek lang... d.h. der kann insg 10sec laufen....

Ist das anders moeglich - OHNE komplett eigenes Thread start run stop interrupt join sich zu basteln ?

danke

ps: gern gesehen sind auch gute seiten / erklaerungen ueber Executor und Konsorten....

 

[byte]

Hoffe ich hab Dich richtig verstanden: Guck Dir mal java.util.concurrent.ExecutorCompletionService<V> an.

 

[bygones]

danke - das schaut schonmal besser aus vom handling her...

problem ist theoretisch immer noch bei dem pull der Klasse.

nach spaetestens X sekunden wird erster geholt, danach nach wieder spaetestens nach X sekunden der zweite. Damit hat der 2. theoretisch nicht X sondern vll 2X sekunden zeit gehabt ....

d.h. wenn ich im grunde sage: Alle Threads muessen nach 30sekunden fertig sein, scheint mir das nicht zu funktionieren.

Denn hier frag ich nach dem ersten der mir innerhalb von 30sek was gibt. Danach weiss ich, dass es noch weitere Threads gibt und frage wieder nach einem der innerhalb von 30sek was zurueck gibt und und und....
also kann man theoretisch nicht nach 30sek fertig sein sondern bei 2 min oder so...

hoffe das war verstaendlicher ?

 

[byte]

OK, Problem erkannt. Hast Du mal probiert, mit ExecutorService#invokeAll(callables, timeout, unit) alle Tasks zu submitten. Dann kannst Du ja so lange die Future-Objekte der Ergebnisliste überwachen, bis der Timeout abgelaufen ist.

Wobei mich jetzt dieser Satz in der Javadoc von invokeAll() etwas irritiert:

Future.isDone() is true for each element of the returned list.

???:L

 

[bygones]

danke dir... das ist es ;-)

public class ThreadExecuterTest {

   public static void main( String[] args ) throws Exception {
        MyCallable c = new MyCallable( "1", 1000 );
        MyCallable c1 = new MyCallable( "2", 200 );
        MyCallable c2 = new MyCallable( "3", 4000 );
        MyCallable c3 = new MyCallable( "4", 6000 );
        
        List<Callable<String>> l = new LinkedList<Callable<String>>();
        l.add(c);
        l.add(c1);
        l.add(c2);
        l.add(c3);
        
        ExecutorService service = Executors.newFixedThreadPool(l.size());
        List<Future<String>> ll = service.invokeAll(l, 5, TimeUnit.SECONDS);
        
        for ( Future< String > future : ll ) {
            try {
                System.out.println(future.get());
            }
            catch(CancellationException e) {
                System.out.println("cancelled");
            }
        }
    }

    static class MyCallable implements Callable< String > {
        private final String b;
        private int i;
        MyCallable( String b, int k ) {
            this.b = b;
            i = k;
        }

        public String call() throws Exception {
            Thread.sleep(i);
            return b;
        }
    }
}

das mal nur als ein dummy test programm

das haette ich vorher schonmal so aehnlich....

entweder alle sind schon vor dem timeout fertig - dann wird die schleife durchlaufen und die ergebnisse geholt, oder er wartet X sekundn und laeuft dann durch und hat die nicht fertigen gecancelled.....