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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
|
public final class SharedReference<T> {
@SuppressWarnings("rawtypes")
private static final Consumer DO_NOTHING = res -> {};
/**
* Couple destructeur / ressource
*
* @param <T>
*/
private static class DestructorRef<T> {
public final T ref;
public final Consumer<T> destructor;
public DestructorRef(T ref, Consumer<T> destructor) {
super();
this.ref = ref;
this.destructor = destructor;
}
}
/**
* Variable locale au thread servant à savoir si on est dans le thread du
* finalize ou non
*/
private static final ThreadLocal<Boolean> FINALISER_HANDLER = new ThreadLocal<Boolean>() {
public Boolean initialValue() {
return false;
}
};
/**
* File de destructeur a appeler
*/
private static final BlockingQueue<DestructorRef<?>> PENDING = new LinkedBlockingQueue<>();
/**
* Thread qui appèle les destructeurs. Son but est d'éviter de laisser le
* garbade collector appeler du code client
*
* @author Sébastien
*
*/
private static class ReferenceHandler extends Thread {
private ReferenceHandler(String name) {
super(name);
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public void run() {
do {
try {
DestructorRef destructorRef = PENDING.take();
destructorRef.destructor.accept(destructorRef.ref);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
} while (!Thread.currentThread().isInterrupted());
}
}
/**
* Initialisation du thread des destructeurs
*/
static {
Thread handler = new ReferenceHandler("Reference Handler");
handler.setPriority(Thread.MAX_PRIORITY);
handler.setDaemon(true);
handler.start();
}
/**
* Wrapper de la référence de l'objet ressource. L'instance gère également
* le compteur
*
* @param <T>
*/
private static final class HardReference<T> {
private final AtomicReference<T> ref;
private final AtomicInteger count;
private final Consumer<T> destructor;
public HardReference(T ref, final Consumer<T> destructor) {
if (ref == null) {
throw new NullPointerException();
}
if (destructor == null) {
throw new NullPointerException();
}
this.ref = new AtomicReference<>(ref);
this.count = new AtomicInteger(1);
this.destructor = destructor;
}
/**
* Méthode thread safe non bloquante. Incrémente le compteur de
* ressource si celle-ci n'est pas déjà détruite.
*/
public void acquire() {
do {
T localRef = this.ref.get();
int localCount = this.count.get();
if (localRef == null || localCount == 0) {
throw new NullPointerException("Resource is null");
}
if (this.count.compareAndSet(localCount, localCount + 1)) {
return;
}
} while (true);
}
/**
* Méthode thread safe non bloquante. Décrémente le compteur de
* ressource si celle-ci n'est pas déjà détruite. Le thread qui atteind
* 0 demande l'appel du destructeur.
*
* Si le thread courant est celui du garbadge collector, l'appel est
* réalisé par thread prévu. Autrement, l'appel se fait directement.
*/
public void release() {
do {
T localRef = this.ref.get();
int localCount = this.count.get();
int newValue = localCount - 1;
if (localCount == 0 || localRef == null) {
return;
}
if (this.count.compareAndSet(localCount, newValue)) {
if (newValue == 0) {
if (this.ref.compareAndSet(localRef, null)) {
if (FINALISER_HANDLER.get()) {
PENDING.add(new DestructorRef<T>(localRef, destructor));
} else {
destructor.accept(localRef);
}
FINALISER_HANDLER.remove();
}
}
return;
}
} while (true);
}
/**
* Retourne l'instance de la ressource uniquement si le compteur n'est
* pas à 0
*
* @return
*/
public T get() {
if (count.get() > 0) {
return ref.get();
}
return null;
}
}
private final HardReference<T> ref;
/**
* Permet de savoir si la référence paratagée a été relachée, ou pas.
*/
private final AtomicBoolean alive;
@SuppressWarnings("unchecked")
public SharedReference(T val) {
this(val, DO_NOTHING);
}
public SharedReference(T val, final Consumer<T> destructor) {
if (val == null) {
throw new NullPointerException();
}
if (destructor == null) {
throw new NullPointerException();
}
this.ref = new HardReference<>(val, destructor);
this.alive = new AtomicBoolean(true);
}
public SharedReference(SharedReference<T> sharedRef) {
if (sharedRef == null) {
throw new NullPointerException();
}
ref = sharedRef.ref;
ref.acquire();
this.alive = new AtomicBoolean(true);
}
/**
* Appelé par le garbadge collector
*/
protected void finalize() throws Throwable {
try {
FINALISER_HANDLER.set(true);
this.release();
} finally {
super.finalize();
FINALISER_HANDLER.remove();
}
}
/**
* Doit être appelé dès que la ressource n'est plus utilisée. Une fois
* appelé, la ressource n'est plus accessible par cet objet.
*/
public void release() {
do {
if (!this.alive.get()) {
return;
}
if (this.alive.compareAndSet(true, false)) {
ref.release();
return;
}
} while (true);
}
/**
* Retourne le nombre d'utilisation actuelle de la ressource
*
* @return
*/
public int count() {
return this.ref.count.get();
}
/**
* Retourne l'instance uniquement si release() n'a pas déjà été appelé avant
*
* @return
*/
public T get() {
if (this.alive.get()) {
return this.ref.get();
}
return null;
}
/**
* Référence faible vers la ressource
*
* @param <T>
*/
public static class WeakReference<T> {
private final HardReference<T> ref;
public WeakReference(final HardReference<T> ref) {
this.ref = ref;
}
public WeakReference(final SharedReference<T> ref) {
this.ref = ref.ref;
}
public int count() {
return this.ref.count.get();
}
/**
* Retourne la ressource uniquement si cette dernière n'a pas été
* relaché par l'ensemble des SharedReference
*
* @return
*/
public T get() {
return this.ref.get();
}
}
} |
Avis - Pointeurs intelligents
).
Répondre avec citation
Partager