1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package io.netty.util.internal;
17
18 import io.netty.util.concurrent.FastThreadLocalThread;
19
20 import java.lang.ref.ReferenceQueue;
21 import java.lang.ref.WeakReference;
22 import java.security.AccessController;
23 import java.security.PrivilegedAction;
24 import java.util.Set;
25 import java.util.concurrent.ConcurrentHashMap;
26 import java.util.concurrent.atomic.AtomicBoolean;
27
28 import static io.netty.util.internal.SystemPropertyUtil.getInt;
29 import static java.lang.Math.max;
30
31
32
33
34
35 public final class ObjectCleaner {
36 private static final int REFERENCE_QUEUE_POLL_TIMEOUT_MS =
37 max(500, getInt("io.netty.util.internal.ObjectCleaner.refQueuePollTimeout", 10000));
38
39
40 static final String CLEANER_THREAD_NAME = ObjectCleaner.class.getSimpleName() + "Thread";
41
42 private static final Set<AutomaticCleanerReference> LIVE_SET = ConcurrentHashMap.newKeySet();
43 private static final ReferenceQueue<Object> REFERENCE_QUEUE = new ReferenceQueue<>();
44 private static final AtomicBoolean CLEANER_RUNNING = new AtomicBoolean(false);
45 private static final Runnable CLEANER_TASK = new Runnable() {
46 @Override
47 public void run() {
48 boolean interrupted = false;
49 for (;;) {
50
51
52 while (!LIVE_SET.isEmpty()) {
53 final AutomaticCleanerReference reference;
54 try {
55 reference = (AutomaticCleanerReference) REFERENCE_QUEUE.remove(REFERENCE_QUEUE_POLL_TIMEOUT_MS);
56 } catch (InterruptedException ex) {
57
58 interrupted = true;
59 continue;
60 }
61 if (reference != null) {
62 try {
63 reference.cleanup();
64 } catch (Throwable ignored) {
65
66
67 }
68 LIVE_SET.remove(reference);
69 }
70 }
71 CLEANER_RUNNING.set(false);
72
73
74
75 if (LIVE_SET.isEmpty() || !CLEANER_RUNNING.compareAndSet(false, true)) {
76
77
78 break;
79 }
80 }
81 if (interrupted) {
82
83 Thread.currentThread().interrupt();
84 }
85 }
86 };
87
88
89
90
91
92
93
94
95 public static void register(Object object, Runnable cleanupTask) {
96 AutomaticCleanerReference reference = new AutomaticCleanerReference(object,
97 ObjectUtil.checkNotNull(cleanupTask, "cleanupTask"));
98
99
100 LIVE_SET.add(reference);
101
102
103 if (CLEANER_RUNNING.compareAndSet(false, true)) {
104 final Thread cleanupThread = new FastThreadLocalThread(CLEANER_TASK);
105 cleanupThread.setPriority(Thread.MIN_PRIORITY);
106
107
108
109
110
111 AccessController.doPrivileged(new PrivilegedAction<Void>() {
112 @Override
113 public Void run() {
114 cleanupThread.setContextClassLoader(null);
115 return null;
116 }
117 });
118 cleanupThread.setName(CLEANER_THREAD_NAME);
119
120
121
122 cleanupThread.setDaemon(true);
123 cleanupThread.start();
124 }
125 }
126
127 public static int getLiveSetCount() {
128 return LIVE_SET.size();
129 }
130
131 private ObjectCleaner() {
132
133 }
134
135 private static final class AutomaticCleanerReference extends WeakReference<Object> {
136 private final Runnable cleanupTask;
137
138 AutomaticCleanerReference(Object referent, Runnable cleanupTask) {
139 super(referent, REFERENCE_QUEUE);
140 this.cleanupTask = cleanupTask;
141 }
142
143 void cleanup() {
144 cleanupTask.run();
145 }
146
147 @Override
148 public Thread get() {
149 return null;
150 }
151
152 @Override
153 public void clear() {
154 LIVE_SET.remove(this);
155 super.clear();
156 }
157 }
158 }