ExecutorService / Thread périodique

Version imprimable

04/04/2012, 11h53
Nalonna

ExecutorService / Thread périodique

Bonjour,

je cherche à exécuter un traitement long dans un thread simple, et à la fin de son exécution mettre à jour l'état d'un bouton de l'interface. A côté de cela, j'ai besoin d'un thread périodique qui permet de mettre à jour l'interface pour afficher un log du traitement lancé dans le précédent thread.

Pour cela, j'ai une pile de message partagé par les 2 threads, mais je cherche à savoir / comprendre comment utiliser les ExecutorService pour faire tout cela.

Est il possible d’exécuter un newSingleThreadExecutor et un newSingleThreadScheduledExecutor dans le même ExecutionService et de gérer ensuite facilement les interactions avec l'interface, de les stopper en cours de route si nécessaire etc.... ???

Si qqun a un lien d'un exemple concret je suis preneuse.

Merci.

Il n'est pas possible de faire un pool du même type, j'ai donc tenté de faire un pool de fixedThreadPool(5) et un pool de ScheduledThreadPool(5).

Les Runnable s'exécutent (et doivent activer un event sur un eventlistener à leur fin d'exécution), mais malheureusement dès que celui qui est périodique (toutes les secondes) prend la main il ne la rend jamais et donc mon process principal ne se poursuit pas.

Qqun aurait il une idée ?

Voici un petit bout d'exemple de code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public void launch(){ ... AsyncTask = new task1(); AsyncThreadPool.submit(task1); ... AsyncTask = new task2(); AsyncScheduledThreadPool.submit(task2); } public void onAsyncTask1(Event event) { processFinished(); } public void onAsyncTask2(Event event) { updateUi(); }
Dès que la task 2 s'exécute, j'ai l'event onAsyncTask2 qui s'exécute en boucle....:aie:

Merci par avance.

Bonjour,

Pour récupérer le résultat d'un calcul quand il est terminé tu peux utiliser les Future<V>.

Par exemple :

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
final ExecutorService pool = Executors.newSingleThreadExecutor();
 
Future<Integer> future = pool.submit(new Callable<Integer>() {
 
	@Override
	public Integer call() throws Exception {
 
			//Attente de 5 secondes pour simuler une action longue
			Thread.sleep(TimeUnit.SECONDS.toMillis(5));
 
			return 10;
		}
	});
System.out.println("On reprend la main après avoir soumis la tâche.");
 
try {
	System.out.println("Quand le resultat est prêt on le récupère : " + future.get());
} 
catch (InterruptedException e) {
	//Le thread a été intérrompu
	e.printStackTrace();
} 
catch (ExecutionException e) {
	//Le code dans call a levé une exception.
	e.printStackTrace();
}
pool.shutdown();

Pour ce qui est des actions périodiques, un exemple d'utilisation de ScheduledExecutorService:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final ScheduledExecutorService scheduledPool = Executors.newSingleThreadScheduledExecutor();
 
scheduledPool.scheduleWithFixedDelay(new Runnable(){
 
	@Override
	public void run() {
		System.out.println("Message affiché toutes les 2 secondes.");
 
	}
 
}, 0, 2, TimeUnit.SECONDS);
 
 
System.out.println("On continu l'exécution pendant que la tâche périodique s'exécute");

Voila, j'espère t'avoir aidé.