[Thread] Arreter un traitement long deja commencé

Version imprimable

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:

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

03/06/2007, 23h23
Invité

salut,
tu peut utiliser une boucle dans le thread, ou bien à chaque lancement d'une recherche lance un thread avec.
03/06/2007, 23h24
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

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:

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; } }; }

03/06/2007, 23h47
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:

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:

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

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

Code:

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);
	}
}

Un truc tout simple aussi : tu mets une variable isInterrupted à ton thread, initialisée à false. Tu mets une autre vaiable done (exprimant quand le travail est fini), toutes les deux booléennes.

Donc :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public void run() { while(isInterrupted || !done) { //faire travail if(travail fini) { done = true; isInterrupted = true; } } }
De cette manière dès que le thread est interrompu on reste dans la boucle sans rien faire. (Attention, ctte solution n'est pas terrible car elle consomme tu CPU, utiliser Thread.spleep comme tu le fais est mieux, mais ça coplique la condition d'entrée de boucle).

On voit aussi que tant qu'on a pas fini de travailler, on rentre dans la boucle et exécute du code. Dès qu'on a fini de travailler, on sort de la boucle et le thread est interrompu afin de pouvoir vraiment en sortir.

Merci à tous,

Mais je voudrais tester le code de pseudocode, mais mon resultats retourne normalement un tableau String[][]. Or, je n'arrive pas à corriger le probleme de conversion String et String[][]

Code:

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
 
public String[][] requete(final String query, long timeout) {
 
			FutureTask<String> future =
			       new FutureTask<String>(new Callable<String>() {
			         public String call() {
			           return requete(query);
// il me dis pour la ligne du dessus : impossible de convertir String[][] en string
			       }});
 
			try {
				new Thread(future).start();
				return future.get(timeout,TimeUnit.SECONDS);
// il me dis pour la ligne du dessus : impossible de convertir String en string[][]
			}  catch (TimeoutException e) {
				future.cancel(true); // Optionnal: interrupt the thread
				return null; // Timeout Exception
			} catch (Exception e) {
				e.printStackTrace(); // Other Exception
				return null;
			}
		}
 
public String[][] requete(final String recherche) {
 
// MA RECHERCHE
}

D'avance merci à ceux qui savent m'aider :)

J'ai fais ca:

Code:

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
public String[][] requete(final String query, long timeout)
		{
 
			FutureTask<String[][]> future =
			       new FutureTask<String[][]>(new Callable<String[][]>() {
			         public String[][] call() {
			           return requete(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;
			}
		}

Je vais tester pour voir si ca fonctionne :)

Et bien, j'ai pas d'erreurs, mais ca s'arrete pas!

J'ai testé meme une boucle comme ceci:

Code:

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
public String[][] requete(final String query, long timeout)
		{
 
			FutureTask<String[][]> future =
			       new FutureTask<String[][]>(new Callable<String[][]>() {
			         public String[][] call() {
			          // return requete(query);
			        	 return test(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 String[][] test(final String recherche)
		{
			String moi[][] = new String[1][1];
 
			int i=1000000;
			while(i!=0)
			{
 
				System.out.println(i);
				i--;
			}
			return moi;
		}

et l'appel:

Code:

String[][] s = request.requete(recherche, 1);

où ets l'erreur?

d'avance merci

EDIT: on fait, à la fin, il va à l'exception timeout (comme quoi le timeout a été dépassé). Mais il le fait qu'à la fin de l boucle qui dure une 15 secondes alors que mon timeout est de 1seconde. Bref, pourquoi après une seconde ne quitte-t-il pas la boucle?

Ton code est correct. Le timeout a bien lieu au bout de 1 seconde.

Pour autant, la thread "future" continue a s'executer car tu n'as pas géré le "future.cancel()" dans ta methode test().

Modifie ta fonction test() comme cela:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public String[][] test(final String recherche) { String moi[][] = new String[1][1]; int i=1000000; while(i!=0) { // Thread has been interrupted ! if (Thread.currentThread().isInterrupted()) return null; System.out.println(i); i--; } return moi; }

04/06/2007, 23h21
Terminator
Bonsoir et merci pour ta réponse

Mais voila, le code suivant:
Code:

1 2 3 4 5 6 7 while(i!=0) { System.out.println(i); i--; } return moi;
Ne peut pas être modifié car il simule mon traitement long et mon traitement long, je peux pas y acceder :(
il est lancé comme ceci dans mon vrai porgramme:
Code:

1 2 String retour = recherche("Mot");
et le probleme, c'est qu'il peut durer TROP longtemps

d'avance merci pour les prochaines reponses

Hum... La bonne chose a faire serait quand meme de modifier le contenu de ta methode: recherche("Mot");

Enfin bon, il y a une solution "sale": faire un Thread.stop()

Je ne conseille pas cela, mais voila les modifs de code a apporter dans la methode requete()
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Thread th = new Thread(future); try { th.start(); return future.get(timeout,TimeUnit.SECONDS); } catch (TimeoutException e) { th.stop(); // unsafe !!!! return null; // Timeout Exception } catch (Exception e) { e.printStackTrace(); // Other Exception return null; }

04/06/2007, 23h36
Terminator

Je sais que le meilleur est de changer dans la recherche. Mais pour tout te dire, c'est l'API de YAHOO qui est appelée, je suis donc dependant de cette API et si la recherche dure longtemps (car serveur surchargé ou autre), j'annule la recherche.

Je vais tester la derniere solution, mais pk tu ne l'as conseille pas? Et est-ce que ca va stopper net la recherche?

d'avance merci pour ton aide :)

EDIT: ca marche tres bien, mais pourquoi c'est deconseillé?
04/06/2007, 23h54
pseudocode

Citation:

Envoyé par Terminator

EDIT: ca marche tres bien, mais pourquoi c'est deconseillé?

http://java.sun.com/j2se/1.4.2/docs/...precation.html

En gros, le Thread.stop "tue" instantanément la thread et libere les verrous. Si la thread était entrain de modifier un objet complexe, cet objet est laissé en l'état: donc potentiellement dans un état incohérent.

Prenons par exemple (c'est juste un exemple) un objet du genre Liste qui contiendrait "les données" et "un compteur de taille".

Normalement, la methode Liste.ajouter() fait cela:

1. "verrouiller" l'objet pout etre seule a y acceder
2. ajoute un element dans les données
3. incremente le compteur de taille
4. "déverrouiller" l'objet.

Si la thread est "tuée" entre l'etape 2 et l'etape 3, la JVM deverouille l'objet et celui-ci est laissé dans un état incoherent.
04/06/2007, 23h55
Terminator

ok, un tout grand merci pour toutes ces precissions, je comprends mieux la dangereusité d'une telle utilisation ;)

cela dit, je sui sobligé de passer par là car j'ai pas d'accès à la class qui gere la recherche :(

encore merci
05/06/2007, 00h05
pseudocode

de rien...

:coucou:
05/06/2007, 00h08
millie

A lire :

http://java.developpez.com/faq/java/...HREAD_terminer

J'ai regardé comment faire pour mettre au moins le stop,

mais je n'y arrive pas du tout :(

Au fait, je fais comme ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
	private boolean stopThread = false;
 
	public synchronized void testFin() throws InterruptedException {
	        if( stopThread ) {
	                throw new InterruptedException();
	        } 
	} 
	public String [][] run(String recherche) {
	        try {
	               return test(recherche);
//****************************
	        } catch( InterruptedException e ) {
//****************************
	        	String alpha[][] = new String[1][1];
	        	 return alpha;
	        } 
	} 
	public synchronized void stop() {
	        this.stopThread = true;
	}

(C'est juste pour tester), mais il met une erreur là:
catch( InterruptedException e )

De plus, je vois pas comment mettre en place mon timeout.

Merci tout de meme pour le lien ;)