Bonjour à tous,
Je débute actuellement en multithreading.
J'ai fait un petit programme qui retourne un tableau (le premier élément devient le dernier etc.)
- Mon algorithme en thread unique est :
- Mon algorithme pour 3 threads est:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8 static int[] inverse (int[] tab){ int[] retour = new int[tab.length]; for (int i = 0; i < tab.length; i++) { retour[i] = tab[tab.length -1 -i]; } return retour; }
- et le code source de mon thread est :
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 static int[] inverse (int[] tab){ int tier = tab.length / 3; ThreadInverse t1 = new ThreadInverse(tab, 0, tier); ThreadInverse t2 = new ThreadInverse(tab, (tier) +1 ,(tier)*2); ThreadInverse t3 = new ThreadInverse(tab, ((tier)*2) + 1, tab.length-1); t1.start(); t2.start(); t3.start(); t1.join(); t2.join(); t3.join(); return t1.getRetour(); }
Ca marche parfaitement mais j'ai remarqué que mon programme était beaucoup moins performant en multhreading qu'en thread unique.
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 public class ThreadInverse extends Thread { private int debut = 0; private int fin = 0; private static int[] tab; private static int[] retour; ThreadInverse(int[] tab, int debut, int fin) { this.debut = debut; this.fin = fin; this.tab = tab; this.retour = new int[tab.length]; } public void run() { for (int i = debut; i <= fin; i++) { retour[i] = tab[tab.length -1 -i]; } } public int [] getRetour() { return retour; } }
Ma métode de test retourne une suite de tableaux dont la taille augmente de 1 à chaque fois. Je pars d'une taille de 1 et mon test se cloture quand la taille du dernier tableau est à 100 000.
La performence négative est elle du à toutes les opérations necessaires pour lancer mes threads?
Pouriez-vous me donner quelques conseils?
Merci beaucoup pour vos réponses
Partager