java.lang.ref.Reference

Java代码

1. Reference提供了一些引用的基本方法以及静态代码块最高优先级启动ReferenceHandler线程

[java] view plain copy print ?

1. Reference提供了一些引用的基本方法以及静态代码块最高优先级启动ReferenceHandler线程

Reference提供了一些引用的基本方法以及静态代码块最高优先级启动ReferenceHandler线程

Java代码

1. package xxx;
3. /**
4. * Abstract base class for reference objects. This class defines the
5. * operations common to all reference objects. Because reference objects are
6. * implemented in close cooperation with the garbage collector, this class may
7. * not be subclassed directly.
8. * 引用对象的抽象基类。这个类定义了所有引用对象的通用行为。
9. * 因为引用对象是通过与垃圾回收期密切合作来实现的，所以不能直接为此类创建子类.
10. *
11. *
12. * @version 1.43, 04/10/06
13. * @author Mark Reinhold
14. * @since 1.2
15. */
16. public abstract class Reference<T> {
17. /* A Reference instance is in one of four possible internal states:
18. * 一种引用实例是可能是四种内部状态之一：
19. * Active: Subject to special treatment by the garbage collector. Some
20. * time after the collector detects that the reachability of the
21. * referent has changed to the appropriate state, it changes the
22. * instance's state to either Pending or Inactive, depending upon
23. * whether or not the instance was registered with a queue when it was
24. * created. In the former case it also adds the instance to the
25. * pending-Reference list. Newly-created instances are Active.
26. * 激活：垃圾回收器特别处理的主题。有时候在回收器检测到被引用(对象)的可达性被改变成适当
27. * 的状态，它会把实例的状态改变成等待状态或者未激活状态，这取决于实例是否被一个队列注册当
28. * 它被创建。在前一种情况下(等待状态),它也往等待-引用集合增加实例。
29. *
30. *
31. * Pending: An element of the pending-Reference list, waiting to be
32. * enqueued by the Reference-handler thread. Unregistered instances
33. * are never in this state.
34. * 等待:一个等待-引用集合里的元素，等待被引用处理线程放入队列中。
35. * 未注册的实例永远不会在这个状态
36. *
37. * Enqueued: An element of the queue with which the instance was
38. * registered when it was created. When an instance is removed from
39. * its ReferenceQueue, it is made Inactive. Unregistered instances are
40. * never in this state.
41. * 入队：实例被创建的时候被登记注册成一个队列的元素。当一个实例从引用队列中删除，它变成非激活状态。
42. * 未注册的实例永远不会在这个状态。
43. *
44. * Inactive: Nothing more to do. Once an instance becomes Inactive its
45. * state will never change again.
46. * 非激活：不会再做什么。一旦一个实例成为非激活的，它的状态永远不会被改变。
47. *
48. *
49. * The state is encoded in the queue and next fields as follows:
50. * 状态在队列里被处理并且每个状态所表现的属性如下：
51. *
52. *
53. * Active: queue = ReferenceQueue with which instance is registered, or
54. * ReferenceQueue.NULL if it was not registered with a queue; next =
55. * null.
56. * 激活：queue=引用队列时候，实例被它注册，
57. * 或者实例不被注册，当queue=ReferenceQueue.NULL时候；
58. * next=null.
59. *
60. * Pending: queue = ReferenceQueue with which instance is registered;
61. * next = Following instance in queue, or this if at end of list.
62. * 等待：queue=引用队列时候，实例被它注册，
63. * next=剩下的queue队列里面的实例，或者=this,如果this是队列的最后一个。
64. *
65. * Enqueued: queue = ReferenceQueue.ENQUEUED; next = Following instance
66. * in queue, or this if at end of list.
67. * 入队：queue=ReferenceQueue.ENQUEUED
68. * next=剩下的queue队列里面的实例，或者=this,如果this是队列的最后一个
69. *
70. *
71. * Inactive: queue = ReferenceQueue.NULL; next = this.
72. * 终止：队列=ReferenceQueue.NULL next=this
73. *
74. * With this scheme the collector need only examine the next field in order
75. * to determine whether a Reference instance requires special treatment: If
76. * the next field is null then the instance is active; if it is non-null,
77. * then the collector should treat the instance normally.
78. *
79. *
80. *
81. * To ensure that concurrent collector can discover active Reference
82. * objects without interfering with application threads that may apply
83. * the enqueue() method to those objects, collectors should link
84. * discovered objects through the discovered field.
85. */
86. private T referent; /* Treated specially by GC */ //被GC引用的对象
87. ReferenceQueue<? super T> queue;//引用队列
88. Reference next;//下个引用
89. transient private Reference<T> discovered; /* used by VM *///被VM引用的瞬态对象
91. /* Object used to synchronize with the garbage collector. The collector
92. * must acquire this lock at the beginning of each collection cycle. It is
93. * therefore critical that any code holding this lock complete as quickly
94. * as possible, allocate no new objects, and avoid calling user code.
95. * GC线程在回收的时候的锁
96. * 对象被用来和GC同步。GC必须获得锁在每个回收的生命周期。
97. * 更关键的是任何持有锁的代码尽可能快的执行完，没有分配新的对象，并避免使用使用者的代码。
98. *
99. */
100. static private class Lock { };
101. private static Lock lock = new Lock();
103. /* List of References waiting to be enqueued. The collector adds
104. * References to this list, while the Reference-handler thread removes
105. * them. This list is protected by the above lock object.
106. * 排队的引用集合。当处理引用的线程删除引用时候，收集器添加引用到这个集合。
107. * 这个集合受上面的对象锁保护。
108. */
109. private static Reference pending = null;
110. /* High-priority thread to enqueue pending References
111. * 处理排队等待的引用的高优先的线程
112. */
113. private static class ReferenceHandler extends Thread {
114. ReferenceHandler(ThreadGroup g, String name) {
115. super(g, name);
116. }
117. public void run() {
118. for (;;) {
119. /*
120. * 给pending赋值
121. * 如果pending.next=pending,pending=null;否则pending=pengding.next,最后把pending.next=pending
122. * 下次执行线程里的代码时候pending=null了，再下次执行同步代码块就线程阻塞了
123. *
124. * 如果pending属性为空，释放锁的对象监视器，阻塞当前线程
125. * */
126. Reference r;
127. synchronized (lock) {
128. if (pending != null) {
129. r = pending;
130. Reference rn = r.next;
131. pending = (rn == r) ? null : rn;
132. r.next = r;
133. } else {
134. try {
135. lock.wait();
136. } catch (InterruptedException x) { }
137. continue;
138. }
139. }
140. // Fast path for cleaners
141. if (r instanceof Cleaner) {
142. ((Cleaner)r).clean();
143. continue;
144. }
145. /*
146. * ReferenceQueue.NULL的实现：
147. * private static class Null extends ReferenceQueue {
148. * boolean enqueue(Reference r) {
149. * return false;
150. }
151. }
152. * 如果Q不为空，把引用放入Queue
153. * 在刚创建一个引用，第二个参数没放Queue时候，为空。
154. * */
155. ReferenceQueue q = r.queue;
156. if (q != ReferenceQueue.NULL) q.enqueue(r);
157. }
158. }
159. }
160. static {
161. //取得当前线程组
162. ThreadGroup tg = Thread.currentThread().getThreadGroup();
163. //取得最上层的System线程组
164. for (ThreadGroup tgn = tg;
165. tgn != null;
166. tg = tgn, tgn = tg.getParent());
167. //创建线程对象
168. Thread handler = new ReferenceHandler(tg, "Reference Handler");
169. /* If there were a special system-only priority greater than
170. * MAX_PRIORITY, it would be used here
171. */
172. handler.setPriority(Thread.MAX_PRIORITY);//设置最高优先级
173. handler.setDaemon(true);//标记守护线程或用户线程
174. handler.start();//守护线程启动
175. }
177. /* -- Referent accessor and setters -- */
178. /**
179. * Returns this reference object's referent. If this reference object has
180. * been cleared, either by the program or by the garbage collector, then
181. * this method returns <code>null</code>.
182. *
183. * @return The object to which this reference refers, or
184. * <code>null</code> if this reference object has been cleared
185. * 获得引用对象
186. */
187. public T get() {
188. return this.referent;
189. }
190. /**
191. * Clears this reference object. Invoking this method will not cause this
192. * object to be enqueued.
193. *
194. * <p> This method is invoked only by Java code; when the garbage collector
195. * clears references it does so directly, without invoking this method.
196. * 清除引用对象
197. */
198. public void clear() {
199. this.referent = null;
200. }
202. /* -- Queue operations -- */
203. /**
204. * Tells whether or not this reference object has been enqueued, either by
205. * the program or by the garbage collector. If this reference object was
206. * not registered with a queue when it was created, then this method will
207. * always return <code>false</code>.
208. *
209. * @return <code>true</code> if and only if this reference object has
210. * been enqueued
211. */
212. public boolean isEnqueued() {
213. /* In terms of the internal states, this predicate actually tests
214. whether the instance is either Pending or Enqueued
215. 是否处于等待状态
216. 判断条件：队列不为空，
217. 它的next属性不为空。
218. 刚初始化一个Reference时候，next属性肯定是空的，因此肯定不处于等待状态
219. */
220. synchronized (this) {
221. return (this.queue != ReferenceQueue.NULL) && (this.next != null);
222. }
223. }
224. /**
225. * Adds this reference object to the queue with which it is registered,
226. * if any.
227. *
228. * <p> This method is invoked only by Java code; when the garbage collector
229. * enqueues references it does so directly, without invoking this method.
230. *
231. * @return <code>true</code> if this reference object was successfully
232. * enqueued; <code>false</code> if it was already enqueued or if
233. * it was not registered with a queue when it was created
234. * 加入等待队列
235. */
236. public boolean enqueue() {
237. return this.queue.enqueue(this);
238. }
240. /* -- Constructors -- */
241. Reference(T referent) {
242. this(referent, null);
243. }
244. Reference(T referent, ReferenceQueue<? super T> queue) {
245. this.referent = referent;
246. this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
247. }
248. }