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

[mehdiing]

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

[mehdiing]

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

[Razgriz]

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 :

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

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.

[Terminator]

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 :

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

[Terminator]

J'ai fais ca:

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

[Terminator]

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

J'ai testé meme une boucle comme 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
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 :

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

	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?

[pseudocode]

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 :

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

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

[Terminator]

Bonsoir et merci pour ta réponse

Mais voila, le code suivant:

Code :

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

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 :

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

1
2
 
 String retour = recherche("Mot");

et le probleme, c'est qu'il peut durer TROP longtemps

d'avance merci pour les prochaines reponses

[pseudocode]

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 :

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

[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é?

[pseudocode]

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.

[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

[pseudocode]

de rien...

[millie]

A lire :

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

[Terminator]

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 :

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