Parallélisme en Java

**thehurrica** · 29/12/2011, 19h04

bonjour,
je veux créer un prog qui calcule la somme d'un tableau en parallèle
c'est-a-dire,
deux processus exécuté en même temps : l'un calcule disant la moite d'un tableau et l'autre processus calcule la deuxième moitie

ce que je veux savoir c'est comment utiliser "Runnable"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class sommeTab implements Runnable{
  public void run(){
  /* est ce que je peux inclure deux fonction a l'interieur de la fonction Run 
  si oui comment ?
  (une pour la première moitie du tableau et une autre pour l'autre moitie) */
  }
}

je ne vous demande pas de me résoudre l'exercice juste m'explique comment le résoudre.

PS : excusez moi pour mon Français

**JoeChip** · 30/12/2011, 10h46

il faut instancier deux Runnable différents et lancer leur start(); du coup tu auras deux threads qui tourneront en même temps.

**oneagaindoguys** · 30/12/2011, 11h15

Ou bien un swingWorker.

J'espère que tu n'espères pas améliorer les perfs en fasant ça...

**Aure7780** · 30/12/2011, 11h27

Regarde plutôt du coté des parallel arrays :
http://blog.paumard.org/2011/10/26/parallel-arrays-1/

**thelvin** · 30/12/2011, 14h53

Envoyé par Aure7780

Regarde plutôt du coté des parallel arrays :
http://blog.paumard.org/2011/10/26/parallel-arrays-1/

Certes. Mais tout cela a plutôt l'air d'un exercice.

**thehurrica** · 30/12/2011, 16h06

merci a vous tous pour vos réponse, je vais essayer de le résoudre avec deux Runnable.

Envoyé par Aure7780

Regarde plutôt du coté des parallel arrays :
http://blog.paumard.org/2011/10/26/parallel-arrays-1/

j'ai déjà vu ce site, mais pour vous dire la vérité, ça ne m'a pas beaucoup aidé

enfin bref, je vais essayé avec ce que m'a proposé BenWillard et je vous dirai ce que ça a donné.

**Aure7780** · 30/12/2011, 17h38

Envoyé par thehurrica

merci a vous tous pour vos réponse, je vais essayer de le résoudre avec deux Runnable.

j'ai déjà vu ce site, mais pour vous dire la vérité, ça ne m'a pas beaucoup aidé

enfin bref, je vais essayé avec ce que m'a proposé BenWillard et je vous dirai ce que ça a donné.

Pour faire la somme d'un tableau c'est simple :

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
Random r = new Random(9999999);
double[] monTab = new double[5000000];
// On remplit le tableau pour les tests
for (int i = 0; i < 5000000; i++)
	monTab[i] = r.nextDouble();
 
long start = 0, end = 0;
double somme = 0;
 
start = System.currentTimeMillis();
// Parallels Array !
// Création du pool pour le multithreading
ForkJoinPool pool = new ForkJoinPool();
// size est un des paramètres de l'algorithme
ParallelDoubleArray pda = ParallelDoubleArray.createFromCopy(monTab, pool);
// Somme
somme = pda.sum();
end = System.currentTimeMillis();
 
System.out.println("Somme (parallel) = " + somme + " en "
		+ (end - start) + "ms");
 
 
// Somme "à la main"
start = System.currentTimeMillis();
for (int j = 0; j < monTab.length; j++) {
	somme += monTab[j];
}
end = System.currentTimeMillis();
 
System.out.println("Somme (classique) = " + somme + " en "
		+ (end - start) + "ms");

pom.xml (Maven pour les dépendances des jar) :

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
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.prozero.parallel</groupId>
	<artifactId>parallel-arrays</artifactId>
	<version>0.0.1-SNAPSHOT</version>
 
	<repositories>
		<repository>
			<id>codehaus-milestone</id>
			<name>codehaus-milestone</name>
			<url>http://repository.codehaus.org</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>
 
	<dependencies>
		<dependency>
			<groupId>org.codehaus.jsr166-mirror</groupId>
			<artifactId>jsr166y</artifactId>
			<version>1.7.0</version>
		</dependency>
 
		<dependency>
			<groupId>org.codehaus.jsr166-mirror</groupId>
			<artifactId>extra166y</artifactId>
			<version>1.7.0</version>
		</dependency>
	</dependencies>
 
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<inherited>true</inherited>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

J'ai fait 2-3 tests, pas très concluant concernant le multithreading (en même temps j'ai pas une super machine...). Donc à voir.
Mais si c'est une somme simple, le calcul de base à l'air très performant.

**JoeChip** · 30/12/2011, 19h44

Regarde plutôt du coté des parallel arrays :

Ouais mais ça c'est pour Java 7 ...

**Aure7780** · 30/12/2011, 20h53

Envoyé par BenWillard

Ouais mais ça c'est pour Java 7 ...

Non ! C'est simplement qu'une partie de la spécification à été implémenté de base dans Java 7. Mais on peut très bien l'utilisé avec Java 1.6 en utilisant les jar de la spéc (jsr166y) !

**JoeChip** · 30/12/2011, 23h52

Ah ok, cool, je vais tester ça un de ces...

**thelvin** · 31/12/2011, 00h09

Soit dit en passant, ça fait un moment que Java 7 est dispo. Même si c'était pour Java 7, c'est quoi le soucis ?

**JoeChip** · 31/12/2011, 12h00

Je ne compte pas installer Java 7 tout de suite, notamment parce que mes clients sont toujours sous 6... En plus j'ai comme règle générale de ne pas me presser pour upgrader, pour diverses raisons...

**thehurrica** · 04/01/2012, 22h36

j'ai réussi a résoudre l'exercice

le principe de cet algorithme est simple :
j'ai utilisé un constructeur qui a pour (entrées): le tableau, indice minimal, et l'indice maximal, que je vais utiliser pour créer mes deux threads :

1- 1er thread avec comme paramétres (le tableau et les indice min et max de la partie qui va executer)

2- pareil pour le deuxième thread (l'autre partie)

et voici donc le code :

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
53
54
 
 
class sommeThrad extends Thread {
    static int s = 0; 
	int y, z;
	int[] x;
 
	public sommeThrad(int[] tab, int min, int max) {
		x = tab; y = min; z = max;
		}
 
	public void run() {
		try {
			Thread.sleep(400);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
 
		for (int i = y; i <= z; i++) {
			s = s + x[i];
			System.out.println("la valeur que contient "+ this.getName() +" a "+i+" = "+s);
 
		}
	}
}
 
public class sommeTab {
	public static void main(String[] args) {
 
		int tableau[]={1,5,6,3,7,8,9,5};
 
		sommeThrad a = new sommeThrad (tableau, 0, 4);
		sommeThrad b = new sommeThrad (tableau, 5, 7);
 
		//demarer les deux Threads
		a.start();
		b.start();
 
		//pour que le prog n'affiche pas la somme tant que les deux Thread sont en execution
			try {
				a.join();
				b.join();
			} catch (InterruptedException e) {
 
				e.printStackTrace();
			}
 
		System.out.println("----------------------------------------");
		System.out.println("                           la somme = " + sommeThrad.s);
 
	}
 
}

mais il existe un petit problème, je veux protéger la variable (s) pour que :
ex : au début s=0
et disant que Thread-1 est le premier a modifier cette var (ex : s=5)
je veux que lorsque Thread-2 exécute le code, il doit trouver (s=0) et non (s=5).

je peux le faire : en mettant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static int s = 0; par int s = 0;

. mais lorsque j’enlève static, le prog m'affiche une erreur a cet partie du code : (la var s)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
System.out.println("----------------------------------------");
		System.out.println("                           la somme = " + sommeThrad.s);

car je veux afficher la somme a la fin du prog (chose que je peux pas faire avec int s = 0; )

alors que faire SVP ? et merci encore

**hwoarang** · 05/01/2012, 09h34

Envoyé par thehurrica

je peux le faire : en mettant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static int s = 0; par int s = 0;

. mais lorsque j’enlève static, le prog m'affiche une erreur a cet partie du code : (la var s)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
System.out.println("----------------------------------------");
		System.out.println("                           la somme = " + sommeThrad.s);

Tu fais un acces static a une variable, c'est pour ca que la variable doit etre static. Il faut donc remplacer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

System.out.println("                           la somme = " + sommeThrad.s);

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
System.out.println("                           la somme pour a = " + a.s);
System.out.println("                           la somme pour b = " + b.s);

Rappelons qu'une variable static est partagée par toutes les instances (dans ton cas par a et b). D'ou ton comportement...

a+

**Aure7780** · 05/01/2012, 10h14

+1 hwoarang

Il faut créer des getter (getS() pour la somme) pour récupérer la valeur des membres depuis l'instance de chaque objet (cas de membres private ou protected).

Petite question, pourquoi fais tu un sleep de 400ms dans ton Thread ? c'est une perte de temps machine.

**Aure7780** · 05/01/2012, 12h05

Je viens de te développer ce que tu veux faire en utilisant toute la puissance de la concurrence en Java :

SumWorker (qui effectue la somme sur une partie du tableau) :

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
public class SumWorker implements Callable<Integer> {
 
	int[] x;
	int min, max;
 
	public SumWorker(int[] x, int min, int max) {
		this.x = x;
		this.min = min;
		this.max = max;
	}
 
	@Override
	public Integer call() throws Exception {
		Integer s = 0;
		for (int i = min; i < max; i++) {
			s += x[i];
		}
		System.out.println(Thread.currentThread().getName() + " - somme = " + s);
		return s;
	}
 
}

SumArrayHelper (qui permet d'utiliser le SumWorker et de gérés le découpage automatique en plusieurs Threads) :

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
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
public class SumArrayHelper {
 
	private static final int MAX_THREAD = 10;
 
	public static long getSum(int[] array, int nbElementByThread) {
 
		List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();
		ExecutorService executor = Executors.newFixedThreadPool(MAX_THREAD);
		for (int i = 0; i < array.length; i += nbElementByThread) {
			// On découpe le tableau en fonction du paramètre nbElementByThread
			int max = ((i + nbElementByThread > array.length) ? array.length
					: i + nbElementByThread);
			// On créer un callable pour le traitement du tableau par morceaux
			Callable<Integer> a = new SumWorker(array, i, max);
			// On envoi la callable pour traitement sur le poll de thread
			Future<Integer> fut = executor.submit(a);
			// On stocke le résultat asynchone dans une liste d'objet Future (cf doc)
			futureList.add(fut);
		}
 
		// On récupère les sommes de chaque Callable et on additionne
		long sum = 0;
		for (Future<Integer> future : futureList) {
			try {
				sum += future.get();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		executor.shutdown();
 
		return sum;
	}
}

Et le code d'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public class CallableTest {
 
	public static void main(String[] args) {		
		int tableau[] = {1,5,6,3,7,8,9,5};	
		// 4 = traite 4 elements du tableau par Thread (Callable)
		long somme = SumArrayHelper.getSum(tableau, 4);		
		System.out.println("Somme = " + somme);			
	}
}

Les Callable sont des taches qui permettent d'avoir une valeur de retour (contrairement au Runnable).

ExecutorService permet de gérer un poll de Threads, c'est à dire un nombre maximum de Thread avec une gestion de file d'attentes (ça evite de faire exploser ta machine avec trop de thread...).

Si tu as des questions sur le code n'hésite pas !

Bon article (en) : http://www.vogella.de/articles/JavaC...y/article.html

**thehurrica** · 05/01/2012, 13h31

Envoyé par hwoarang

Tu fais un acces static a une variable, c'est pour ca que la variable doit etre static. Il faut donc remplacer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

System.out.println("                           la somme = " + sommeThrad.s);

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
System.out.println("                           la somme pour a = " + a.s);
System.out.println("                           la somme pour b = " + b.s);

Rappelons qu'une variable static est partagée par toutes les instances (dans ton cas par a et b). D'ou ton comportement...
a+

merci hwoarang voila ce que j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int sommeTotal=(a.s)+(b.s);
		System.out.println("----------------------------------------");
		System.out.println("                         la somme = " + sommeTotal);

et ça marche

Envoyé par Aure7780

+1 hwoarang
Petite question, pourquoi fais tu un sleep de 400ms dans ton Thread ? c'est une perte de temps machine.

je l'ai ajouté juste pour voir les Threads s’exécuter l'un après l'autre (pour voir un peu plus le parallélisme

parce que je ne le vois pas avec mon OS (Win7): il fini Thread-0 après il commence Thread-1 ou le contraire (pas tout le temps mais !), c'est pourquoi j'ai utilisé la fonction sleep)

**thehurrica** · 05/01/2012, 13h38

Envoyé par Aure7780

Je viens de te développer ce que tu veux faire en utilisant toute la puissance de la concurrence en Java :

Les Callable sont des taches qui permettent d'avoir une valeur de retour (contrairement au Runnable).

ExecutorService permet de gérer un poll de Threads, c'est à dire un nombre maximum de Thread avec une gestion de file d'attentes (ça evite de faire exploser ta machine avec trop de thread...).

Si tu as des questions sur le code n'hésite pas !

Bon article (en) : http://www.vogella.de/articles/JavaC...y/article.html

merci beaucoup Aure7780 je comprends mieux maintenant qu'est ce que fait ExecutorService parce que j'ai déjà vu ce site, mais j'ai pas compris son rôle (vu que je suis un débutant en JAVA

).

pouvez-vous m'expliquer un peu plus ArrayList (quand et pourquoi, on l'utilise)

**Aure7780** · 05/01/2012, 14h22

Envoyé par thehurrica

pouvez-vous m'expliquer un peu plus ArrayList (quand et pourquoi, on l'utilise)

Je te propose de regarder la FAQ : http://java.developpez.com/faq/java/...info_framework

**thehurrica** · 05/01/2012, 17h28

Envoyé par Aure7780

Je te propose de regarder la FAQ : http://java.developpez.com/faq/java/...info_framework

merci Aure7780

et a vous tous pour vos réponses et vos explications, so thanks a lot

maintenant je peux mettre le sujet comme (RÉSOLU)

ET MERCI ENCORE !

Parallélisme en Java

Java

Discussions similaires

Partager

Partager