[THREAD][BLOCKINGQUEUE] Comment éviter un 'freeze' ?

Bonjour,
J'ai un Thread T1 qui ajoute des données dans un ArrayBlockingQueue. J'en ai un autre T2 qui récupère les objet à partir de cette Queue.
Comment faire pour éviter que T2 ne se bloque en demant à la queue de lui fournir encore un objet alros que T1 n'a plus rien à ajouter ?

merci

Salut,

Tu peux utiliser la méthode poll() à la place de take(), qui permet de définir un timeout...

a++

ouais mais je trouve pas ça très propre car si mon traitement dans T1 prend plus de temps que prévu il rique d'y avoir des soucis :(
Mais je garde cette solution sous le coude, merci :)

Quelques solutions :

Si tu connais à l'avance le nombre d'objet que ton thread T1 va passer à T2, il suffit de partager cette information entre les deux threads...

Tu peux utiliser un objet "marqueur" qui sera envoyé systématiquement à la fin par le producteur. Donc ton thread consommateur devra vérifier l'objet recu avant de le traiter :

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
47
48
49
50
        final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);
        final String END = new String("END");
 
        Thread productor = new Thread("Productor") {
            @Override
            public void run() {
                System.out.println(getName() + " : START");
                Random r = new Random();
                for (int i=0; i<5; i++) {
                    // Simule le traitement long (entre 0 et 5 secondes) :
                    try {
                        Thread.sleep( r.nextInt(5000) );
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
 
                    String data = "Ligne " + i;
                    System.out.println(getName() + " --> " + data);
                    queue.offer(data);
                }
                queue.offer(END);
                System.out.println(getName() + " : FIN");
            }
        };
 
 
        Thread consumer = new Thread("Consumer") {
            @Override
            public void run() {
                System.out.println(getName() + " : START");
                while(true) {
                    try {
                        String data = queue.take();
                        // Si on est arrivé à la fin "on quitte"
                        if (data==END) {
                            break;
                        }
                        // Sinon on traite les données :
                        System.out.println(getName() + "  <-- " + data);
 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(getName() + " : FIN");
            }
        };
 
        productor.start();
        consumer.start();

Sinon tu peux utiliser la méthode poll() avec un timeout, et le coupler avec un Semaphore : le Semaphore est acquis avant de lancer les deux threads, et ton thread T1 ne le libère qu'à la fin de son traitement. Ainsi lorsque ton thread T2 recois un timeout sur la méthode poll(), il doit vérifier l'état du Semaphore pour continuer ou pas :

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
47
48
49
50
51
52
53
        final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);
        final Semaphore semaphore = new Semaphore(1);
        semaphore.acquire();
 
        Thread productor = new Thread("Productor") {
            @Override
            public void run() {
                System.out.println(getName() + " : START");
                Random r = new Random();
                for (int i=0; i<5; i++) {
                    // Simule le traitement long (entre 0 et 5 secondes) :
                    try {
                        Thread.sleep( r.nextInt(5000) );
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
 
                    String data = "Ligne " + i;
                    System.out.println(getName() + " --> " + data);
                    queue.offer(data);
                }
                semaphore.release(); // libération de la sémaphore
                System.out.println(getName() + " : FIN");
            }
        };
 
 
        Thread consumer = new Thread("Consumer") {
            @Override
            public void run() {
                System.out.println(getName() + " : START");
                while(true) {
                    try {
                        String data = queue.poll(500, TimeUnit.MILLISECONDS);
                        // Si on recoit des données on les traite :
                        if (data!=null) {
                            System.out.println(getName() + "  <-- " + data);
                        }
                        // Sinon on tente d'aquerir le semaphore
                        // pour savoir si le producteur est fini :
                        if (data==null && semaphore.tryAcquire()) {
                            break;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(getName() + " : FIN");
            }
        };
 
        productor.start();
        consumer.start();

a++

Merci beaucoup adiGuba !
ta dernière solution est, je pense, la meilleur :)
J'avas pensé utiliser un objet marqueur, mais le type d'objet que j'ajoute dans la queue ne le permet pas (à moins que je ne fasse une Queue<Object> mais je préfère Queue<MonObject>)

T'es un chef adiGuba :P

Citation:

Envoyé par narmataru

J'avas pensé utiliser un objet marqueur, mais le type d'objet que j'ajoute dans la queue ne le permet pas (à moins que je ne fasse une Queue<Object> mais je préfère Queue<MonObject>)

Pourquoi ? Tu peux très bien utiliser un MonObject comme marqueur puisque la comparaison s'effectues sur les références et non pas les valeurs...

a++

Ok j'avas pas fait attention que c'était la référence qui était testée et non la valeur :roll:
Mais je préfère quand même la seconde méthode qui est utilise des vrai system de synchronisation :aie: