[Java 1.5] Question facile java.util.concurrent package

Bonjour,

J'aimerai savoir si quelqu'un a déjà utilisé ce package, et si oui, j'aimerai savoir si les locks sont gérés automatiquement par l'objet, où si je dois faire quelquechose.
Je cherche également une liste qui me permette de faire du FIFO, et que je dépile.
En gros, mon besoin est le suivant, j'ai une classe, dont j'aimerai avoir des méthodes static permettant d'ajouter des messages, et que celle ci soit également un Thread, qui dépile au fur et à mesure.
Vous pouvez me donner un coup de pouce avec ce nouveau package, je pense que c'est le bon !!
Merci à tous.

Salut,

C'est bien le package qu'il te faut !
Et en particulier l'interface BlockingQueue qui permet de gérer des queues bloquantes (ou non).

Ses implémentations sont thread-safe et tu n'a donc pas à manipuler des lock ou des synchronized :mrgreen:

Il te suffit donc de les utiliser comme une simple collections, en utilisant les méthodes les plus adapté selon tes besoins, par exemple take() permet de récupérer un élément en le supprimant de la queue, et bloquera tant que la queue est vide, tandis-que poll() te renverra directement null dans ce cas...

Par exemple dans ton cas ton thread pourrait ressembler à ceci :

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
37
38
39
40
41
42
43
44
45
46
abstract class MyTask<E> extends Thread {
 
	/** Queue qui stockera les données avant le traitement */
	private final BlockingQueue<E> queue = new LinkedBlockingQueue<E>();
 
 
	/**
         * "Envoi" les données au thread.
         * En fait lles données sont passé à la Queue qui sera ensuite lu par le thread
         * @param str
         */
	public final void send(E...args) {
		// On ajoute tout les éléments un à un :
		for (E data : args) {
			this.queue.offer(data);
		}
	}
 
 
	/**
         * Méthode qui traitera les données reçus.
         * @param data
         */
	public abstract void received(E data);
 
 
	/**
         * Traitement du thread
         * On récupère les éléments de la queue et on les traite
         */
	public void run() {
 
		try {
			E current;
			// take() permet de récupérer le premier element de la queue
			// en bloquant le thread courant tant que la liste est vide...
			while ( !isInterrupted() && (current=this.queue.take()) != null) {
 
				// On appelle la méthode qui traitera les données :
				received(current);
 
			}
		} catch (InterruptedException e) { /* condition de fin */ }
		System.out.println("FIN DU THREAD");
	}
}

Exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
	public static void main(String[] args) throws Exception {
 
		// On crée un nouveau Thread qui utilisera des String :
		MyTask<String> task = new MyTask<String>() {
			@Override
			public void received(String data) {
				System.out.println("Received : [" + data + "]");
			}
		};
		task.start(); // on démarre le thread
 
		task.send("Hello !", "World !");
 
		Thread.sleep(2000);
 
		task.send("Bye Bye");
		task.interrupt();
	}

Ce qui donnera :

Code:

1
2
3
4
Received : [Hello !]
Received : [World !]
Received : [Bye Bye]
FIN DU THREAD

a++

Cool !!!!
Trop classe !
Et encore merci pour l'exemple !!
A charge de revanche . :king: