Question sur les LinkedList et les threads
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:
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:
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:
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.
