Discussion :

[yaya0057]

Bonjour,

J'aimerais avoir un petit conseil.
J'aurais voulu connaitre la meilleure manière de gérer le démarrage et l'arrêt d'un Thread
Ci-dessous, j'ai posté deux classes.
La première contient la méthode run du thread et j'aurais voulu savoir comment je pouvais arrêter et redemarrer ce même Thread à partir de la seconde classe.

merci d'avance à tous

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
 
public class FixTimeConsumer implements Runnable {
............
        public void run() {
		while( true )	{
			try {
				List<TaskCS> taskCSs = oracleService.getResumeCSUs();
				if ( !taskCSs .isEmpty() ) {
					new RunJobPlanThread( taskCSs );
				} else {
 
				}
 
				Thread.sleep( 30000 );
			} catch ( Exception e ) {
				throw new MainException( 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
 
public class RunJobPlanThread {
................
        public void initRunJobPlanThread() {
		List<Callable<RunJobPlanTaskCallable>> tasks = new ArrayList<Callable<RunJobPlanTaskCallable>>();
 
		//On ajoute ces taches à la liste
		Callable<RunJobPlanTaskCallable> runJobPlanTask;
 
		for ( TaskCS taskCS : taskCSs ) {
			runJobPlanTask = new RunJobPlanTask( taskCS );
			tasks.add( runJobPlanTask );
		}
 
                ExecutorService executor = Executors.newFixedThreadPool( fixedThreadPool );
		launchRunJobPlanTask( executor, tasks );
	}
 
	public void launchRunJobPlanTask( final ExecutorService executor, List<Callable<RunJobPlanTaskCallable>> tasks ) {
		CompletionService<RunJobPlanTaskCallable> completionService = new ExecutorCompletionService<RunJobPlanTaskCallable>( executor );
		List<Future<RunJobPlanTaskCallable>> futures = new ArrayList<Future<RunJobPlanTaskCallable>>();
		RunJobPlanTaskCallable runJobPlanTaskCallable = null;
 
		try {
			for( Callable<RunJobPlanTaskCallable> task : tasks ){
				futures.add( completionService.submit( task ) );
			}
 
			// Ici il faut arrêter le thread.
 
			for ( int i = 0; i < tasks.size(); i++ ) {
				runJobPlanTaskCallable = completionService.take().get();
 
				if ( runJobPlanTaskCallable != null ) {
					String errorLevel = runJobPlanTaskCallable.getErrorLevel();
					String errorMessage = runJobPlanTaskCallable.getErrorMessage();
					this.runJobPlanTaskCallables.add( runJobPlanTaskCallable );
				}
 
				if ( this.runJobPlanTaskCallables.size() == tasks.size() ) {
 
				}
			}
		} catch( Exception e ){
			throw new MainException( e );
		} finally {
			executor.shutdown();
		}
	}
...............
}

[thelvin]

Il y a trop de choses mélangées, ici.

Quand on a un thread qui tourne tout le temps et dont on veut parfois qu'il s'arrête et qu'il reprenne dans certaines conditions, la méthode classique est le wait()/notify().

Exemple :

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
private boolean finished = false;
private boolean condition = true;
 
private synchronized void waitForCondition() {
  while(!condition && !finished) {
    wait();
  }
}
 
public synchronized void setCondition(boolean condition) {
  this.condition = condition;
  if(condition) {
    notifyAll();
  }
}
 
public synchronized void setFinished() {
  this.finished = true;
  notifyAll();
}
 
@Override
public void run() {
  while(!finished) {
    waitForCondition();
    // faire des trucs
  }
}

Mais ça se mêle mal aux ExecutorServices, qui en principe reçoivent des tâches à la chaîne à exécuter, et dédient leurs threads à ça. Si on fait ça dans un de leur thread, il se retrouve inutilisable pendant l'attente et ils ne peuvent donc pas exécuter d'autres tâches avec ce thread, qui pourtant ne fait rien d'autre qu'attendre.

Logiquement tu ne devrais pas avoir besoin d'interrompre des tâches que tu envoies à un ExecutorService, ou alors, les interrompre définitivement et sans redémarrer.

Comme toujours avec les threads, il faudrait qu'on ait une idée plus concrète de ce que tu cherches à réaliser.

[yaya0057]

Merci d'abord pour ta réponse.

Le but est le suivant:
Le thread principale éxécute une requete qui recupère une liste de taches a effectué en fonction de l'heure qu'il est.
Cette tache doit s'effectuer tous les 30 secondes.

Une fois les tâches récupérée, on les éxécute grâce à l'ExecutorService. Je désire donc arréter le thread de récupération de la liste des tâches
car si le nombre de tâche à éxécuter est conséquente elles prendront plus de trente secondes.

Donc je veux eviter de récupérer une nouvelle liste de tâche si il y a en a déjà une en cours d'éxécution.

Merci

[thelvin]

Stop stop stop, "les tâches," "cette tâche," de quoi on parle et quand ? Des noms, un dessin.

Et quand on commence une phrase par "le but est le suivant," les mots qui suivent ne sont jamais "Le thread." "L'ordinateur," "le verger," "la facture," "le tracteur," ce genre de choses mais pas "le thread."

[yaya0057]

Oui effectivement, ce qui est clair pour moi l'est pas obligatoirement pour les autres.

Toutes les 30 secondes, avec un thread, je récupère une liste de tâches à effectuer.
Ces tâches sont ensuite exécutées grâce au service ExecutorService.
Pendant que le service ExecutorService tourne je désire arrêter le thread cité ci dessus.

J'espère que c'est plus clair.

[Népomucène]

à vue de nez, la classe Timer est un meilleurs choix que le Thread
Cette classe s'assure que la tâche est bien finie avant de se relancer

[thelvin]

Toutes les 30 secondes, avec un thread, je récupère une liste de tâches à effectuer.
Ces tâches sont ensuite exécutées grâce au service ExecutorService.
Pendant que le service ExecutorService tourne je désire arrêter le thread cité ci dessus.

C'est pas mal, mais ça pourrait être interprété ainsi :

"Mon programme fait une requête qui lui donne une liste de tâche à faire. Il exécute les tâches (en les envoyant à un ExecutorService et en attendant qu'elles se terminent.) Puis il attend 30 secondes et recommence."

[Népomucène]

Mouaip ! c'est exactement ce fait Timer

[thelvin]

... Ouaip, while et sleep() aussi -_-°.

[Népomucène]

... Ouaip, while et sleep() aussi -_-°.

Certes, certes ...
Mais comme Timer est déjà construit pour cela ...

[tchize_]

Bonjour,

J'aimerais avoir un petit conseil.
J'aurais voulu connaitre la meilleure manière de gérer le démarrage et l'arrêt d'un Thread

Arrêter: remplacer ton while(true) par un while(condition) et faire passer cette condition à vrai.

Redémarrer: ce n'est pas possible, il faut en créer un nouveau.

Les Runnable ne sont pas des Threads, il sont utilisés par des Threads, au passage (mais pas exclusivement).

[yaya0057]

Bonjour,

J'ai bien pris note de toutes vos réponses, et je vous remercie tous.

Merci