Discussion :

[Terminator]

Bonjour à tous,

Je veux faire un truc assez simple à expliquer mais plus difficile à mettre en place!

J'ai un traitement (qui est une recherche). Cette recherche se fait via l'utilisation d'une méthode dont j'ai pas assez (pas au code).
Ca se fait en une ligne: exemple: String retour = recherche("Mot");

Mais quelques fois cette recherche a un probleme (sans retour de probleme, donc pas possible d'utiliser un try/catch). Ce probleme, je en le conais pas (exemple: reponse TROP longue d'un serveur, une boucle infini,...)

Je souhaite arreter le traitement aprsè X secondes. Pour ce faire, j'ai pensé utiliser un thread.
Mais la façon que j'ai eu de coder ne va pas car le thread peut s'arreter qu'une fois la tache stoppée.

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
 
 Thread th = new Thread(){
	        	public synchronized void run(){
	        		try{        			
	        			sleep(timeout);
	        		}catch(Exception e){e.printStackTrace();}
 
	        		if (recu == false)
	        			stop = true;
	        	}
	        };
 
 
 
 
 
 try 
	        {	        	
	        	synchronized(this)
	        	{        
	                if (!stop)
	                { 
	                    String retour = recherche("Mot");              
	                }
	                if (stop)
	                {
	                	System.err.println("\nHors delai: " +timeout + " ms depasse");
 
	                }
	        	}
	        }
	        catch (IOException e) {
	            }

Comment puis-je faire pour arreter cette recherche deja lancée avec un thread? (ou une autre manière)?

D'avance merci à tous,

PS: désolé pour les tabulations infinies, mais c'est le copier/coller

[Invité]

salut,
tu peut utiliser une boucle dans le thread, ou bien à chaque lancement d'une recherche lance un thread avec.

[Terminator]

Bonsoir,

Merci pour ta reponse, mais je ne comprends pas trop la solution!

Une boucle dans le thread: tu veux dire quoi par là?
Et la deuxieme?

D'avance merci

[Invité]

salut,
si j'ai bien compris ton problème tu veut que le thread qui stoppe le traitement ne se termine pas et reste toujours en action. pour cela tu peut soit lancer le thread à partir du code de la fonction de recherce ou bien utiliser une boucle dans le code du thread :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 Thread th = new Thread(){
	        	public synchronized void run(){
while(true)
{
	        		try{        			
	        			sleep(timeout);
	        		}catch(Exception e){e.printStackTrace();}
 
	        		if (recu == false)
	        			stop = true;
	        	}
	        };
}

[Terminator]

Heuuu... pas exactement (enfin, si je t'ai bien compris)

Au fait, je vais expliquer en francais le programme que je souhaite obtenir:

Code :

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

1
2
3
LANCER Thread
FAIRE String retour = recherche("Mot");  
MAIS ARRETER SI JE DEPASSE 10 SECONDES

En gros, je veux un timeout et qd il est dépassé, je veux arreter la recheche.

Pour que ce soit encore plus clair:
Je veux faire UNE seule recherche, donc pas de boucle:
ca donne exactement le cas francisé:

Code :

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

1
2
3
4
5
DEBUT PROGRAMME
LANCER Thread (10 seconde de timeout)
FAIRE String retour = recherche("Mot");  
Si je recois le reponse en moins de 10 sec, alors ok
Sinon, ARRETER la recherche lancée

D'avance merci

[pseudocode]

Si tu utilises Java 5 ou 6, il y a les classes du package concurrent

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
 
public class Search {
 
	public String search(String query) {
 
		/******************/
		/* VOTRE CODE ICI */
		/******************/
 
		return "RESULT OF SEARCH";
	}
 
	// recherche avec timeout
	public String search(final String query, long timeout) {
 
		FutureTask<String> future =
		       new FutureTask<String>(new Callable<String>() {
		         public String call() {
		           return search(query);
		       }});
 
		try {
			new Thread(future).start();
			return future.get(timeout,TimeUnit.SECONDS);
		}  catch (TimeoutException e) {
			future.cancel(true); // Optionnal: interrupt the thread
			return null; // Timeout Exception
		} catch (Exception e) {
			e.printStackTrace(); // Other Exception
			return null;
		}
	}
 
	public static void main(String[] args) {
		Search mysearch = new Search();
 
		// résultat sans timeout
		String result1 = mysearch.search("mot");
		System.out.println(result1);
 
		// résultat avec timeout
		String result2 = mysearch.search("mot",10);
		System.out.println(result2);
	}
}