Discussion :

[berg]

bonjour,

J ai 2 type de thread : Th et Thh.

les threads de type Th depilent les données de la linked list, et les thread de type Thh les empilent.

Je me suis posé la question de savoir si l ajout des données dans une LinkedList devait etre faite de mainiere exclisive. Car contrairement a la classe Vector, la classe LinkedList n'est pas "thread-safe".

voila l architecture de mon programme :

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
public class Th implements Runnable
{
	LinkedList lk;
	Thread t;
 
	public Th() {
		lk = new LinkedList();
		t = new Thread(this);
		t.start();
	}
 
	public synchronized void add(String data) throws InterruptedException {		
		lk.addFirst(data);
		notifyAll();
	}
 
 
	public synchronized String pop() throws InterruptedException {
		while (lk.size() == 0)
			wait();
		return lk.removeLast() + "";
	}
 
	public void run() {
		while(true)
			try
			{
				System.out.println("th extrait " + pop());
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
	}
 
}

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
public class Thh implements Runnable
{
	int num;
	Th th;
	Thread t;
 
	public Thh(int num, Th th) {
		this.num = num;
		this.th = th;
		t = new Thread(this);
		t.start();
	}
 
	public void run() {
		while(true) {
			System.out.println("Thread " + num + "commence ajouter");
			try {
				th.add("zzzzzz " + num);
			}
			catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("Thread " + num + "fini ajouter");
		}
	}
}

je lance le programme dans le main en faisant ceci :

Code :

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

1
2
3
4
Th th = new Th();
		Thh t1 = new Thh(1, th);
		Thh t2 = new Thh(2, th);
		Thh t3 = new Thh(3, th);

voila ce que j obtient (une petite partie) :


Thread 2commence ajouter
Thread 1commence ajouter
Thread 3fini ajouter
th extrait zzzzzz 1
Thread 2fini ajouter
Thread 1fini ajouter
Thread 3commence ajouter
th extrait zzzzzz 1
Thread 2commence ajouter
Thread 1commence ajouter
Thread 2fini ajouter
Thread 2commence ajouter
Thread 2fini ajouter
Thread 2commence ajouter
Thread 2fini ajouter
Thread 2commence ajouter
Thread 2fini ajouter
Thread 2commence ajouter
Thread 2fini ajouter
Thread 2commence ajouter
Thread 2fini ajouter
Thread 1fini ajouter
th extrait zzzzzz 1
Thread 3fini ajouter
Thread 1commence ajouter
th extrait zzzzzz 1
Thread 3commence ajouter
Thread 1fini ajouter
th extrait zzzzzz 1
Thread 3fini ajouter
Thread 1commence ajouter
th extrait zzzzzz 1
Thread 3commence ajouter
Thread 1fini ajouter
th extrait zzzzzz 3
Thread 3fini ajouter
Thread 1commence ajouter
th extrait zzzzzz 2
Thread 3commence ajouter
Thread 3fini ajouter
Thread 3commence ajouter
Thread 3fini ajouter
Thread 3commence ajouter
Thread 3fini ajouter
Thread 3commence ajouter
Thread 3fini ajouter
Thread 3commence ajouter


Le synchronized évidemment n agit pas sur les threads de type Thh (c est bon). Par contre pourquoi le thread Th depile alors que les thread Thh empile en même temps ?? Normalement lorsqu'une thread veut exécuter une méthode d'instance portant le modificateur synchronized, Java verrouille l'instance de classe. Donc Th ne devrait pas retirer.

D apres les resultat trouvé, il n est pas la peine de gere l exclusion mutuelle entre les thread de type Thh pour ajouter une élément dans la liste. Par contre il faut que l action retirer et ajouter restent disctint.

Voila ma question, est ce qu il est convenable de laisser ca comme ca ou alors je risque d avoir des problemes au bout d un moment (je l ai laissé tourner plusieurs minutes)? la fonction add de LinkedList gere automatiquement l ajout avec les threads ?

Merci.

[berg]

Je vais faire la bonne et vieille methode,
Une classe qui comprend les methode a synchronizer et ayant comme parametre les threads. Ou alors rajouter une semaphore.

Mais j attend quand meme des réponses .

[adiGuba]

Salut,


En effet tu peux avoir des soucis si deux thread modifie le même élément... même si le cas ne se présente pas forcément...
Le plus sûr étant de synchronizer la List avec Collections.synchronizedList() :

Code :

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

List list = Collections.synchronizedList(new LinkedList());

a++

[berg]

AAAAAAa ce que j ai fait etait bon, le probleme venait de mes System.out.println(message) qui n etait pas dans mes fonction synchronized.

Dans mon programme si dessus, il y a un intervalle de temps X entre afficher et executer le fonction synchronized. Entre cette intervalle, une autre thread faire autre chose.

Merci quand meme adiguba pour ta reponse.


J aurai une question apres changement de mon programme (j ai simplement mis les System.out dans le add), pourquoi quelque fois j ai toujours :

Thread 1commence ajouter
th extrait zzzzzz 2
Thread 1fini ajouter

Pourtant les System.out est par defaud sychronized.
Par contre quand je je fait :

Code :

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

1
2
3
4
5
6
7
8
9
public synchronized void pop() throws InterruptedException
	{
		while (lk.size() == 0)
		{
			System.out.println("WWWWWWWAAAAAAIIIIIIIIIITTTTTTTT ");
			wait();
		}
		System.out.println("th extrait " + lk.removeLast());
	}

Je n ai plus ce probleme.