Discussion :

[comtention]

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 :

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;
}

- Mon algorithme pour 3 threads 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();
}

- 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
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;
	}
}

Ca marche parfaitement mais j'ai remarqué que mon programme était beaucoup moins performant en multhreading qu'en thread unique.

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

[Pill_S]

il manque un "Thread.yield();" dans la boucle de la méthode run

[comtention]

A oui c'est vrai j'avais appris cette instruction en plus. Merci.

Mais malheureusement les performances ont diminuées d'encore 3 fois plus que sans le yiel().

[Deaf]

C'est normal, car en multi-thread, tu effectues les même opérations qu'en mono-thread avec en plus la création/gestion des threads.
Donc tu ne peux être plus rapide que si tu travailles sur plusieurs processeurs et qu'ils sont correctement exploités, et encore, ça dépend des tâches à effectuer.

Si tu veux tester l'intérêt du multi-thread, il faut que tu aies des temps de latence (réponse d'une appli tierce, de l'utilisateur, de l'OS, ...) dans les différentes tâches.
Tu dois pouvoir le simuler en ajoutant un "Thread.sleep(10);" dans la boucle de la méthode inverse.

[Deaf]

Comme je ne suis pas persuadé d'avoir été très clair, je vais imager:

Tu as trois écrivains (tes 3 threads) qui doivent écrire chacun un paragraphe d'une lettre. Ils ne disposent que d'un stylo (1 processeur).

S'ils connaissent la lettre à écrire par coeur (= pas de temps de latence), ils iront moins vite qu'un écrivain seul car ils perdront du temps à se passer le crayon.

Par contre, si chacun doit réfléchir avant chaque phrase (avec temps de latence), ils pourront optimiser le temps : l'un écrira pendant que les autres réfléchiront.

Là, ils pourront aller plus vite si les temps de réflexion sont important à côté du temps perdu à se passer le crayon.


Et cette image fonctionne aussi pour expliquer l'utilité d'avoir plusieurs processeurs/stylos

[comtention]

Ouai ok donc dans mon cas je peux pas aller plus vite qu'avec un seul thread car je n'ai pas de temps de latence entre mes operations et également parce que je n'ai qu'un seul processeur. c'est bien ca?

Merci beaucoup pour ces informations.

[wax78]

Comme je ne suis pas persuadé d'avoir été très clair, je vais imager:

Tu as trois écrivains (tes 3 threads) qui doivent écrire chacun un paragraphe d'une lettre. Ils ne disposent que d'un stylo (1 processeur).

S'ils connaissent la lettre à écrire par coeur (= pas de temps de latence), ils iront moins vite qu'un écrivain seul car ils perdront du temps à se passer le crayon.

Par contre, si chacun doit réfléchir avant chaque phrase (avec temps de latence), ils pourront optimiser le temps : l'un écrira pendant que les autres réfléchiront.

Là, ils pourront aller plus vite si les temps de réflexion sont important à côté du temps perdu à se passer le crayon.


Et cette image fonctionne aussi pour expliquer l'utilité d'avoir plusieurs processeurs/stylos

Très bonne explication.

Pour gagner du temps avec plusieur thread sur une processeur il fautdrati que tu fasses des I/O (par exemple) et que celles ci soient +- bloquantes pour remarquer un gain. Sinon en effet ca sera le contraire qui va se produire (echange du stylo).