Discussion :

[nono_31]

Bonjour,

Je réalise un test sur un algorithme pseudo-polynomial. Je souhaiterait limiter le temps d'exécution de la méthode contenant l'algorithme.

Ma première idée a été d'utiliser des threads pour tuer le processus quand la limite est dépassée. C'était assez facile à faire en utilisant la méthode depreciée stop().
J'aimerai bien que mon programme survive au prochains passages de versions et j'ai donc cherché une autre solution.
La solution présentée dans la plupart des tutos consiste à créer un timer à la main et à tester le temps. L'avantage est que je n'ai plus besoin de threads mais je dois modifier le code de ma méthode. Je trouve ça encore plus nul.

Est-ce que quelqu'un à une solution élégante à me proposer ?

merci

[verbose]

Ouep, tu peux utliser la classe Thread pour ça. Il te suffit de paramétrer ton thread avec la méthode Thread.join() avant de le lancer en spécifiant le nombre de millisec que tu veux donner à ton processus pour s'exécuter.

[nono_31]

La méthode join() mer permet d'interrompre facilement un thread au bout d'un certain temps. Mais comment tuer le thread sans utiliser la méthode stop() dans l'exemple suivant

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
 
public class ExThread extends Thread{
 
	public ExThread(String name) {
		super();
		this.setName(name);
	}
 
 
	public void run() {
		for(int i=0;i<5000;i++) {
			System.out.println("Thread nommé : " + this.getName()+" - itération : " + i);
		}
	}
 
 
	static public void main(String argv[]) {
		ExThread thr1 = new ExThread("Toto");
		try {
 
			thr1.start();
			thr1.join(1);
			thr1.stop(); //deprecated : que faire pour arreter thr1 sans modifier thr1.run()  ?
			System.out.println("\n\nthread principal\n\n");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

[®om]

Bonjour,

Je réalise un test sur un algorithme pseudo-polynomial. Je souhaiterait limiter le temps d'exécution de la méthode contenant l'algorithme.

Ma première idée a été d'utiliser des threads pour tuer le processus quand la limite est dépassée. C'était assez facile à faire en utilisant la méthode depreciée stop().
J'aimerai bien que mon programme survive au prochains passages de versions et j'ai donc cherché une autre solution.
La solution présentée dans la plupart des tutos consiste à créer un timer à la main et à tester le temps. L'avantage est que je n'ai plus besoin de threads mais je dois modifier le code de ma méthode. Je trouve ça encore plus nul.

Est-ce que quelqu'un à une solution élégante à me proposer ?

merci

Il faut que la méthode contenant ton algorithme "prévoit" des endroits où elle peut s'arrêter :

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
private boolean interrupt;
 
public void method() throws InterruptedException {
    //début du calcul
    checkInterrupted();
    //suite du calcul
    checkInterrupted();
    //fin du calcul
}
 
public synchronized void checkInterrupted() throws InterruptedException {
    if(interrupt) {
        throw new InterruptedException();
    }
}
 
public synchronized void interrupt() {
    interrupt = true;
}

Ensuite il suffit d'appeler interrupt depuis un autre thread...
Tu peux t'inspirer (par exemple) de ce post: http://www.developpez.net/forums/sho...d.php?t=395029

[nono_31]

Merci pour ta réponse.

Justement, je ne souhaite pas modifier la classe de mon algorithme. Je pourrais bien sur le modifier exclusivement pour les tests, mais je cherche une réponse générique me permettant d'interrompre ce thread. Je pourrai ainsi l'utiliser pour d'autres algos.

L'algorithme n'utilise aucune structure de données partagée et donc il n'y a pas de risques (dans mon cas) à utiliser la méthode stop().
Quels sont les autres risques dues à l'utilisation de cette méthode dépréciée ?

[verbose]

La méthode join() mer permet d'interrompre facilement un thread au bout d'un certain temps. Mais comment tuer le thread sans utiliser la méthode stop() dans l'exemple suivant

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
 
public class ExThread extends Thread{
 
	public ExThread(String name) {
		super();
		this.setName(name);
	}
 
 
	public void run() {
		for(int i=0;i<5000;i++) {
			System.out.println("Thread nommé : " + this.getName()+" - itération : " + i);
		}
	}
 
 
	static public void main(String argv[]) {
		ExThread thr1 = new ExThread("Toto");
		try {
 
			thr1.start();
			thr1.join(1);
			thr1.stop(); //deprecated : que faire pour arreter thr1 sans modifier thr1.run()  ?
			System.out.println("\n\nthread principal\n\n");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

La méthode join() est précisément celle qu'il te faut. Simplement, il y a une erreur dans ton code. La méthode join() doit être appelée avant start(). Par ailleurs, il est inutile d'appeler stop() après join() puisque le processus s'arrêtera obligatoirement après le temps que tu as défini.

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
public class ExThread extends Thread{
	public ExThread(String name) {
		super();
		this.setName(name);
	}
	public void run() {
		for(int i=0;i<5000;i++) {
			System.out.println("Thread nommé : " + this.getName()+" - itération : " + i);
		}
	}
	static public void main(String argv[]) {
		ExThread thr1 = new ExThread("Toto");
		try {
			thr1.join(1); //le thread s'arrêtera environ 1 millisec après avoir démarré
			thr1.start();
			System.out.println("\n\nthread principal\n\n");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

[®om]

La méthode join() est précisément celle qu'il te faut.

Pas du tout, la méthode join() est bloquante dans le thread courant, avec éventuellement un timeout, mais en aucun cas cela stoppe le thread qui exécute le traitement long, celui sur lequel tu appelles join() !

[nono_31]

Pas du tout, la méthode join() est bloquante dans le thread courant, avec éventuellement un timeout, mais en aucun cas cela stoppe le thread qui exécute le traitement long, celui sur lequel tu appelles join() !

Je suis d'accord, la modification proposée ne marche pas (le processus long s'exécute en entier).

[verbose]

Oui, exact, dsl. C'est vrai qu'en y réfléchissant join() définit un timeout et non une durée de vie.

[verbose]

A défaut de solution "générique" pour arrêter un thread, je te propose une classe qui exécute en boucle un fragment de code en appelant une méthode de vérification à chaque itération :

Code :

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

1
2
3
4
5
6
7
8
9
 
public abstract class Stoppable extends Thread {
	public final void run() {
		while(doesContinue())
			fragment();
	}
	protected abstract void fragment();
	protected abstract boolean doesContinue();
}