关闭

java.lang.ref.Reference

2753人阅读 评论(0) 收藏 举报
Java代码 复制代码 收藏代码
  1. Reference提供了一些引用的基本方法以及静态代码块最高优先级启动ReferenceHandler线程  
Java代码 复制代码 收藏代码
  1. package xxx;   
  2.     
  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引用的瞬态对象   
  90.   
  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();   
  102.   
  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.         }   
  176.   
  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.         }   
  201.   
  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.         }   
  239.   
  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.     }  
1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:404616次
    • 积分:4662
    • 等级:
    • 排名:第6490名
    • 原创:70篇
    • 转载:125篇
    • 译文:1篇
    • 评论:80条
    最新评论