Discussion :

[dark2]

Bonjour à tous,

Je travaille sur la synchronisation en Java et j'ai regardé que par exemple, la collection Vector est un type synchronisé alors que ArrayList n'en est pas un.
Pour les comparer j'utilise l'algorithme suivant :

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
 
public class CoutSynchronisation {
 
	final static int TAILLE = 100000;
 
	public static void main(String[] args) {
		System.out.println("Cout de la synchronisation");
		parcoursVector();
		parcoursArrayList();
	}
 
	private static void parcoursVector() {
 
		System.out.println("Vector est un type synchronisé par défaut");
		Vector<Integer> vector = new Vector<Integer>();
		long start1 = System.currentTimeMillis();
		for (int i = 0; i < TAILLE; i++) {
			vector.add(i);
		}
		for (int i = 0; i < TAILLE; i++) {
			vector.remove(TAILLE-i-1);
		}
		long end1 = System.currentTimeMillis();
		long duree = end1 - start1;
		System.out.println("duree : " + duree + " ms");
 
	}
 
	private static void parcoursArrayList() {
		System.out.println("ArrayList est un type non synchronisé");
 
		ArrayList<Integer> arrayList = new ArrayList<Integer>();
		long start2 = System.currentTimeMillis();
 
		for (int i = 0; i < TAILLE; i++) {
			arrayList.add(i);
		}
		for (int i = 0; i < TAILLE; i++) {
			arrayList.remove(TAILLE-i-1);
		}
		long end2 = System.currentTimeMillis();
		long duree = end2 - start2;
		System.out.println("duree : " + duree + " ms");
	}
}

Ce programme me permet de chronometrer le temps d'ajout et de suppression d'entiers dans un vector et une arrayList.
Le probleme c'est que les resultats ne sont pas ceux que j'attendais.
Je pensais trouver l'arrayList plus rapide que le vector alors que la les resultats me semblent tres aleatoires.
Merci de m'eclairer à ce sujet. Comment faire pour prouver que la synchronisation a un coût.

[adiGuba]

Salut,


Deux remarques :

• La précision de System.currentTimeMillis() dépend fortemetn du système. Par exemple sous Windows elle est généralement de 16ms. Ce qui fait que tu peux avoir un différence de 32ms sur un test (start + stop), et donc de 64ms sur deux tests. Bref il faut que ton traitement dépasse les 100ms pour avoir quelque chose de cohérent...
• Avec les JVMs actuelles, le cout de la synchronisation est nettement moins important qu'il ne l'était avant. Il y a de forte chance que la différence ne soit pas si importante que cela...

a++

[maxf1]

Pour voir un plus grand ecart sur la synchronization, tu devrais peut-etre mettre 2 thread qui remplissent la meme liste et la peut-etre que le cout de la synchronization serait plus flagrante. Et aussi agrandir un peu la taille, ne pas hésitez à faire des tests sur des grandes listes.

A savoir que la synchronization est bien si plusieurs Object peuvent modifier le meme élément, sinon ca n'a aucune utilité, du moins je n'en vois pas qui me saute aux yeux comme ca.

[maxf1]

Personnellement j'ai repris ton code et j'ai testé chez moi. Rajoute un p'tit '0' à ta taille et tu verra la difference est flagrante. Le Vector est plus que 2 fois plus lent!!

[®om]

D'ailleurs, si tu veux tester la synchronisation sur une liste, compare les objets :

Code :

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

new ArrayList<Object>();

avec

Code :

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

Collections.synchronizedList(new ArrayList<Object>());

En effet, la 2e solution est quand même plus rapide que Vector...


Et si tu ne t'intéresse qu'à la synchro, le plus simple est de faire:

Code :

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

1
2
public synchronized void methodSynchro() {}
public void methodNonSynchro() {}

Et tu les appeles plein de fois...
J'ai déjà fait ce test, le rapport est d'environ 7.

[®om]

Voici un exemple qui compare la durée pour incrémenter un compteur de 0 à NB_ITER par rapport à la durée pour incrémenter un compteur PLUS la synchronisation sur un verrou:

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 TestSynchro {
 
    public static void main(String... args) {
        final Object lock = new Object();
        final int NB_ITER = 1000000;
 
        long t;
 
        t = System.nanoTime();
        for (int i = 0; i < NB_ITER; i++) {
            synchronized(lock) {}
        }
        System.out.println(System.nanoTime() - t);
 
        t = System.nanoTime();
        for (int i = 0; i < NB_ITER; i++) {
 
        }
        System.out.println(System.nanoTime() - t);
    }
 
}

Code :

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

1
2
20125742
2874667

ça fait (presque) tout pile un rapport de 7