Problème avec CyclicBarrier(2)

Bonjour,

Je suis en train de mettre en place un programme qui gere un petit multi threading avec deux threads.

Hors chez moi ca marche mais chez un client ca ne marche pas.

J'ai l'impression en regardant ces logs que un des threads est relaché trop tot...

Ma question est donc : Est il possible qu'un threads cencé etre bloqué, soit relache sans meme qu'un exception soit levé ????

Merci d'avance

d'après la doc : "If a thread leaves a barrier point prematurely because of interruption, failure, or timeout, all other threads waiting at that barrier point will also leave abnormally via BrokenBarrierException (or InterruptedException if they too were interrupted at about the same time). "
es tu sûr qu'aucune exception ne soit levée? on peut voirun extrait sommaire du code?

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package fr.ifp.first.hubopt;
 
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
 
import org.apache.log4j.Logger;
 
 
public class HubOptMultiThreadManage {
 
    /** this objects manage the status **/
    HubOptStatus hubOptStatus;
 
    private AHMStatus ahmStatus;
 
    private final CyclicBarrier waitStatus;
 
    private final CyclicBarrier waitParam;
 
    private final CyclicBarrier waitResult;
 
    private final CyclicBarrier waitHubopt;
 
    private static final Logger LOGGER = Logger.getLogger(HubOptMultiThreadManage.class.getName());
 
    public HubOptMultiThreadManage() {
 
        waitStatus = new CyclicBarrier(2);
 
        waitParam = new CyclicBarrier(2);
 
        waitResult = new CyclicBarrier(2);
 
        waitHubopt = new CyclicBarrier(2);
    }
 
    /**
     * this method allows to stop the differents waiters.
     */
    public void stopWaiters() {
 
    }
 
    /**
     * this method allows to notify all object when the workflow is interrupted
     */
    public void notifyAllObject() {
 
    }
 
    /**
     * this method allows
     * 
     * @return
     */
    public int waitStatus() {
        System.out.println("Status " + waitStatus.getNumberWaiting());
        try {
            waitStatus.await();
        }
        catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
        catch (BrokenBarrierException e) {
            throw new IllegalStateException(e);
        };
 
        return 1;
    }
 
    /**
     * this method allows
     * 
     * @return
     */
    public int waitParam() {
        System.out.println("param " + waitParam.getNumberWaiting());
        try {
            waitParam.await();
        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return 0;
        }
        catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return 0;
        }
        return 1;
    }
 
    /**
     * this method allows
     * 
     * @return
     */
    public int waitResult() {
 
        System.out.println("result " + waitResult.getNumberWaiting());
        try {
            waitResult.await();
        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return 0;
        }
        catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return 0;
        }
 
        return 1;
 
    }
 
    /**
     * this method allows
     * 
     * @return
     */
    public int waitHubopt() {
 
        System.out.println("hubopt " + waitHubopt.getNumberWaiting());
 
        try {
            waitHubopt.await();
        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return 0;
        }
        catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return 0;
        }
        return 1;
 
    }
 
}

moui ... (on devrait donc avoir une trace quoiqu'il arrive .... si toutes les exceptions sont bien signalées)
mais qui s'échappe de quoi?