Discussion :

[Dev_info]

Bonjour,

j'ai deux threads qui accedent à un objet de type linkedList qui forme une file d'attente, l'un des threads emfile un ou des objets (addFirst) et l'autre retire ces objets (getLast), si la transaction réussit il fait removeLast.
je veux savoir si je dois gerer l'accès concurrentiel de threads à 7 objet. tenant compte que l'un des threads change seulement le debut de la liste et l'autre la fin.
sinon avec un exemple ce sera mieux.
Merci d'avance

[adiGuba]

Salut,


Oui tu dois synchroniser les accès à la liste sous peine d'avoir de mauvaise surprise (et de manière totalement aléatoire).

Si tu utilise Java 5.0 tu peux utiliser directement ConcurrentLinkedQueue...

a++

[Dev_info]

Merci bien adiGuba
Oui, j'utilise java 5, donc je vais profiter de ConcurrentLinkedQueue.
Est que vous avez une idée pour gerer la pérsistance de cette file pour eviter tout éventuelle perte, que se soit JDO ou autres .

Remerci

[Dev_info]

Salut,
J'ai deux threads qui accèdent à une file d'attente, l'un dépose l'autre retire les objets de le file, j'ai pu developper le code au dessous et ça marche, mais le pb, c'est que je ne peux pas deposer sans retirer.ce-ci dû au fait que le thread reste en wait() jusqu'à notify(), qui vient de l'autre thread .donc je veux savoir d'après vous qu'elles sont les modifs necessaire pour que le thread déposant puisse deposer sans que l'autre retire ! ;-)

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
 
 
import java.util.concurrent.ConcurrentLinkedQueue;
 
public class FileAttente {
	private ConcurrentLinkedQueue<ElemFileAttente> file = new ConcurrentLinkedQueue<ElemFileAttente>();
 
	private boolean available = false;
 
	public synchronized void emfiler(ElemFileAttente elem) {
		while (available == true) {
			try {
				wait();
			} catch (InterruptedException e) {
			}
 
		}
		file.add(elem);
		available = true;
		System.out.println("th1: Depot\n");
		notifyAll();
 
	}
 
	public synchronized ElemFileAttente defiler() {
		ElemFileAttente elem = null;
		while (available == false) {
			try {
				wait();
			} catch (InterruptedException e) {
			}
 
		}
		elem = (ElemFileAttente) file.poll();
		available = false;
		System.out.println("th2: Retrait \n");
		notifyAll();
 
		return elem;
 
	}
 
}

[adiGuba]

donc je veux savoir d'après vous qu'elles sont les modifs necessaire pour que le thread déposant puisse deposer sans que l'autre retire ! ;-)

Tu n'as pas besoin de gérer la synchronisation: c'est déjà fait par la ConcurrentLinkedQueue. Cette classe permet à un thread d'ajouter des éléments à une queue pendant qu'un autre les enlève, sans que les deux threads ne se bloquent mutuellement (mis à part en cas d'accès simultanée).

Par contre si tu veux un comportement bloquant, il vaut mieux utiliser les BlockingQueue, par exemple :

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
public class FileAttente {
	private BlockingQueue<ElemFileAttente> file = new LinkedBlockingQueue<ElemFileAttente>(1); // 1 seul élément
 
	public void emfiler(ElemFileAttente elem) {
		// Ajout d'un element dans la queue,
		// (bloquant si la queue est pleine)
		file.put(elem);
		System.out.println("th1: Depot\n");
	}
 
	public ElemFileAttente defiler() {
		// Récupération d'un élément
		// (bloquant si la queue est pleine)
		ElemFileAttente elem = file.take();
		System.out.println("th2: Retrait \n");
		return elem;
 
	}
}

a++