Discussion :

[ploxien]

Hello,

J'ai des thread (Callable en fait).
Je les mets dans une liste d'attente

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Executor executor = Executors.newFixedThreadPool(3);
CompletionService<String> completionService =
            new ExecutorCompletionService<String>( executor );
 
completionService.submit( new Th2("2.1") );
completionService.submit( new...
 
...
 
for(int i...){
  Future<String> result = completionService.take();
  System.out.println(result.get());
}

dans ces threads, je fais des appels systèmes. Comment est-ce que je peux faire pour que si après 1sec par exemple l'appel système n'a pas répondu, le thread se termine?
Quelles sont les possibilités? En fait, je voudrais faire un timeout général, donc sur tous les threads, ainsi qu'un plus précis sur chaqun d'entre eux!
Merci, A+

[®om]

dans ces threads, je fais des appels systèmes.

Quand tu dis appels systèmes, c'est des Runtime#exec()?

[ploxien]

Quelquechose du genre
En fait j'utilise une librairie qui fait cela mieux que Runtime#exec dans mon cas... Mais derrière, c'est ça qui est utilisé...
C'est une librairie Shell de adiguba, touvée sur ce forum

Pourquoi?

Merci,
A+

[®om]

Dans un thread ça aurait marché (tu fais interrupt sur le thread, ça interrompait le waitFor, et juste derrière tu fais un kill du process).
Mais avec un Callable dans un ExecutorService, je ne sais pas comment on peut spécifier "je veux un interrupt sur CE callable"...

EDIT: mais oui, sur ton Future<?> tu fais un cancel(true)... ! non?
(donc il faut que tu récupères ton Future dès le submit)

[ploxien]

Concrétement, si j'ai cela, je fais comment?

Thread (callable):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.concurrent.Callable;
 
// Callable
public class Th1 implements Callable<String>{
 
    String name;
 
    public Th1(String name){
        this.name = name;
    }
 
    public String call() throws Exception {
        System.out.println("Start thread "+this.name);
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return new String("Return thread "+this.name);
    }
 
}

Classe de test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
public class Test {
    public static void main(String[] args){
 
        Executor executor = Executors.newFixedThreadPool(3);
        CompletionService<String> completionService =
            new ExecutorCompletionService<String>( executor );
 
        completionService.submit( new Th1("1.1") );
        completionService.submit( new Th1("1.2") );
        completionService.submit( new Th1("1.3") );
        completionService.submit( new Th1("1.4") );
 
        try {
            for(int i=0;i<4;i++){
                Future<String> result;
                result = completionService.take();
                System.out.println(result.get());
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Le but serait que le thread meurt après un certain temps s'il n'est pas terminé!

Je ne vois pas... Merci d'avance!

A+

edit: c'est un exemple qui ne comporte pas d'appel système, mais le principe est le même...

[®om]

Tu peux faire une classe qui gère le Timeout de tes futures:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class FutureTimeout {
 
	private static final ScheduledExecutorService TIMER = Executors.newSingleThreadScheduledExecutor();
 
	public FutureTimeout(final Future<?> source, long delay, TimeUnit unit) {
		Runnable cancel = new Runnable() {
			@Override
			public void run() {
				source.cancel(true);
			}
		};
		TIMER.schedule(cancel, delay, unit);
	}
 
}

Et comme submit renvoit un Future, tu peux faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Future<String> future = completionService.submit( new Th1("1.1") );
new FutureTimeout(future);

C'est une idée "en gros", après faut raffiner si tu veux pouvoir changer le timeout, annuler le timeout, etc...

[ploxien]

Ok, ca fonctionne, mais est-ce que je peux encore, de cette manière, submitter 200 threads et ensuite attendre la première réponse que je recoit?

Car si je dois faire un Future pour chaque thread, c'est pas super... non?
genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Future<String> result = completionService.submit( new Th1("1.1") );
new FutureTimeout(result, 1000, TimeUnit.MILLISECONDS);
result = completionService.submit( new Th1("1.2") );
new FutureTimeout(result, 1000, TimeUnit.MILLISECONDS);

Comment faire?

Merci, A+

[®om]

Ok, ca fonctionne, mais est-ce que je peux encore, de cette manière, submitter 200 threads et ensuite attendre la première réponse que je recoit?

Car si je dois faire un Future pour chaque thread, c'est pas super... non?
genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Future<String> result = completionService.submit( new Th1("1.1") );
new FutureTimeout(result, 1000, TimeUnit.MILLISECONDS);
result = completionService.submit( new Th1("1.2") );
new FutureTimeout(result, 1000, TimeUnit.MILLISECONDS);

Comment faire?

Merci, A+

En fait plus proprement, change ta classe FutureTimeout en ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class FutureTimeout {
 
	private FutureTimeout() {}
 
	private static final ScheduledExecutorService TIMER = Executors.newSingleThreadScheduledExecutor();
 
	public static void timeout(final Future<?> source, long delay, TimeUnit unit) {
		Runnable cancel = new Runnable() {
			@Override public void run() {
				source.cancel(true);
			}
		};
		TIMER.schedule(cancel, delay, unit);
	}
 
}

Au passage, tu peux faire 1 SECONDS au lieu de 1000 MILLISECONDS

Car si je dois faire un Future pour chaque thread, c'est pas super... non?

De toute façon le submit te renvoie un future, que tu l'ignores ou non

[ploxien]

Oui, mais imaginons que je fasse cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
        Future<String> resultTemp;
        resultTemp = completionService.submit( new Th1("1.1") );
        FutureTimeout.timeout(resultTemp, 1000L, TimeUnit.MILLISECONDS);
        resultTemp = completionService.submit( new Th1("1.2") );
        FutureTimeout.timeout(resultTemp, 1000L, TimeUnit.MILLISECONDS);

Je ne peux plus faire une boucle qui attend le premier retour, telle que celle que j'avais avant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
            for(int i=0;i<4;i++){
                Future<String> result;
                result = completionService.take();
                System.out.println(result.get());
            }

Comment faire quelquechose d'identique? En sachant que le premier thread à retourner un résultat ne sera pas forcément le premier à avoir été créé, et qu'il peut y en avoir beaucour (500-1000)

Merci

A+

[ploxien]

Ah non, en fait je viens de comprendre, je peux faire cela, il faut juste que je traite le cas ou le thread est annulé...

Je vais tester, ca devrait jouer!

merci!

A+

[ploxien]

cf:
http://www.developpez.net/forums/sho...d.php?t=396348

Merci