Bonjour,

j'ai une exécution à faire en parallèle.
J'avais donc créé une classe qui étendait de Thread.
Le problème est que cette exécution peut remonter des exceptions or il est impossible de modifier la signature de la méhode run() de l'interface Runnable.

J'ai cherché un peu et Callable semble répondre à mon besoin, le hic est que je ne parviens pas à faire une réelle exécution en parallèle.
Quand je lance ma 1ère classe Callable puis ma seconde, le traitement de la 1ère s'effectue, puis une fois terminée le traitement de la seconde commence.

J'aurai donc besoin de vos conseils car je ne suis pas sûr d'utiliser Callable comme il se doit.

Voici 2 exemples :
- le 1er utilise Thread et quand on lance le programme on voit bien dans la console que les exécutions des 2 threads sont faites en parallèle
- le 2nd utilise Callable (qui pourra lever une exeception en modifiant sa signature) mais quand on l'exécute on voit dans la console que la 1ère exécution s'effectue puis séquentiellement la 2nde.

L'affichage de l'identifiant du thread courant montre également qu'en utilisant les Threads on a bien 3 identifiants différents (1 pour le main, 1 deuxième pour le 1er Thread et un 3ème pour le 2nd Thread) alors que dans le 2ème exemple on a seulement 1 seul identifiant pour les 3 entités (main + 1er Callable + 2nd Callable) d'où ma déduction que les exécutions se font en séquentiel ....

1er exemple : utilisant Thread
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
 
public class MyThread extends Thread {
	private String name;
 
	public MyThread(String pName) {
		super();
		name = pName;
	}
 
	public void run() {
		System.out.println("ID " + name + " ===> "
				+ Thread.currentThread().getId());
		for (int i = 0; i < 100; i++) {
			System.out.println(name + "Iteration " + i);
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		System.out.println("ID MAIN ===> " + Thread.currentThread().getId());
		MyThread t1 = new MyThread("Thread 1 ");
		t1.start();
		MyThread t2 = new MyThread("Thread 2 ");
		t2.start();
	}
 
}
2ème exemple : utilisant Callable
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
 
import java.util.concurrent.Callable;
 
public class MyCallable implements Callable {
	private String name;
 
	public MyCallable(String pName) {
		super();
		name = pName;
	}
 
	public Thread.State call () {
		System.out.println("ID " + name + " ===> " + Thread.currentThread().getId());
		for (int i=0; i<100; i++) {
			System.out.println(name + "Iteration " + i);
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
 
		return Thread.State.TERMINATED;
	}
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		System.out.println("ID MAIN ===> " + Thread.currentThread().getId());
		MyCallable t1 = new MyCallable("Thread 1 ");
		t1.call();
		MyCallable t2 = new MyCallable("Thread 2 ");
		t2.call();
	}
 
}
Ma question est donc comment faire un réel traitement multithread avec 2 exécutions en parallèle tout ayant la possibilité de remonter des exceptions de ces traitements.