RefenceQueue的源码解析,以及WeakHashMap的源码分析

Java RefenceQueue WeakHashMap


首先介绍Java中的四种引用:

  1. 强引用:如Object c = new Object() 这种引用。如果一个对象有强应用,那么这个对象就不会被释放!即使内存不够时候,JVM会给出OutOfMemory异常。
  2. 软引用:SoftReference,软引用的对象,会在JVM内存不够的情况下被JVM回收。
  3. 弱引用:WeakReference,弱引用,在下一次GC的时候,会被GC清理。
  4. 虚引用:PhantomReference,形同虚设的引用,设置这个引用的对象,没法通过虚引用获得,这个引用设置一般也就是为了GC时候的一个提醒。

上面的SoftReference和WeakReference和PhantomReference,都是Reference的子类,我们来看看这个类的源码:

Reference的四种状态:

  1. Active:新建的Reference对象是处于这个状态的,(queue可能有,next为null)。
  2. Pending:等待被ReferenceHandler放入ReferenceQueue,如果Reference的Queue不存在,那么就不会处于这个状态,会被直接回收。(queue不为空,next=this)
  3. Enqueued:已经被加入ReferenceQueue的Reference对象,如果没有提供Queue,那么永远不会处于这个状态。如果从Queue中移出,就处于InActive状态。(queue = ReferenceQueue.Enqueued,next=ReferenceQueque的下一个元素。如果只有Queue中只有一个,那么就是this)
  4. InActive:这是最终的状态,一旦处于这个状态,就再也不会更改了。(queue = NULL,next = this)

private T referent : 属性,这个属性的是泛型T,代表,引用的具体指向对象。
volatile ReferenceQueue queue:Reference的Queue对象。
Reference next : 这个属性和Queue一起组成了四种状态的标志。
Reference discovered:这个字段是虚拟机使用的,用来标识,下一个GC的Reference对象。
Reference pending : 这个字段代表,等待被处理的Reference的对象,这个对象一般被ReferenceHandler线程所消费!

内部类 ReferenceHandler :

private static class ReferenceHandler extends Thread

public void run() {
            while (true) {
                tryHandlePending(true);
            }
}

继承自Thread,提供了一个很特别的run方法,死循环运行tryHandlePending方法。

 static boolean tryHandlePending(boolean waitForNotify) {
        Reference r;
        Cleaner c;
        try {
            synchronized (lock) { //加锁,确保读取到的是最新的pending对象
                if (pending != null) {
                    r = pending;  //r表示正在处理的Reference对象!
                    // 'instanceof' might throw OutOfMemoryError sometimes
                    // so do this before un-linking 'r' from the 'pending' chain...
                    c = r instanceof Cleaner ? (Cleaner) r : null;
                    // unlink 'r' from 'pending' chain
                    pending = r.discovered; // 将下一个GC的对象放入pending
                    r.discovered = null;    / 将discovered去除。
                } else {
                    // The waiting on the lock may cause an OutOfMemoryError
                    // because it may try to allocate exception objects.
                    if (waitForNotify) {
                        lock.wait();        //如果没有等待处理的Reference对象,就进入等待,这个由JVM唤醒的
                    }
                    // retry if waited
                    return waitForNotify;
                }
            }
        } catch (OutOfMemoryError x) {
            // Give other threads CPU time so they hopefully drop some live references
            // and GC reclaims some space.
            // Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
            // persistently throws OOME for some time...
            Thread.yield();
            // retry
            return true;
        } catch (InterruptedException x) {
            // retry
            return true;
        }

        // Fast path for cleaners
        if (c != null) {
            c.clean();
            return true;
        }

        ReferenceQueue q = r.queue;     //取出Reference的Queue
        if (q != ReferenceQueue.NULL) q.enqueue(r);         //如果Queue不为NULL,就做入队的操作。
        return true;
    }

需要注意的是:ReferenceHandler这个线程是在Reference类被加载的时候,启动的!优先级最高,后台线程!

至此Reference的我们就分析完毕了!我们明白了,Reference是通过Reference的Handler,不断的将GC标记的Reference放入Queue中的!

我们再来看下ReferenceQueue的源码:

ReferenceQueue NULL:给没有设置Queue的Reference对象设置一个默认的Queue。但是无法做入队的操作。
ReferenceQueue ENQUEUED:对已经放入Queue的Reference对象,将其的Queue设置为ENQUEUED。
Reference head:队列的头。其实ReferenceQueue是个链表。

从上面的ReferenceHandler中我们看到,线程会不断的执行Queue的enqueue对象:下面解析这个方法的源码:

boolean enqueue(Reference r) { /* Called only by Reference class */
        synchronized (lock) {
            // Check that since getting the lock this reference hasn't already been
            // enqueued (and even then removed)
            ReferenceQueue queue = r.queue;  
            if ((queue == NULL) || (queue == ENQUEUED)) {  //如果queue是NULL或者ENQUEUED就不做处理。
                return false;
            }
            assert queue == this;
            r.queue = ENQUEUED;     //将原来的Reference对象的Queue设置为ENQUEUED
            r.next = (head == null) ? r : head; //将当前处理的Reference设置为队列的头部
            head = r;
            queueLength++;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(1);
            }
            lock.notifyAll();   //唤醒阻塞的方法,如remove方法。
            return true;
        }
    }

Queue中,还有一些方法,我们一个个解析:
poll方法,最终调用的是 reallyPoll 方法:检测队列是否为空,不为空就处理头部元素,返回头部元素,或者null。

remove方法,最终调用remove(timeout)方法!如果timeout为0,表示如果没有元素会一直等待!如果大于0,如果队列为空就等待一段时间。

Reference和ReferenceQueue的源码,讲解结束!总结下就是,ReferenceQueue的作用就是在Reference的内部元素被GC回收的时候,会把Reference加入到Queue中,然后我们通过监听Queue的元素,可以得到元素被回收的事件,针对这个事件,我们可以做其他事情。

WeakHashMap中,比较常用的使用了Reference的知识,下面我们来看看它的源码:

WeakHashMap的源码分析:

首先我们要知道WeakHashMap和普通的Map的不同:

  1. WeakHashMap的元素是会变化的。

  2. WeakHashMap的Entry的Key是WeakReference,所以在Key,可以被回收的时候,可以得到相应的通知!

  3. WeakHashMap 在 put,get和Size操作的时候都会执行expungeStaleEntries(去除多余的Entry)的方法,将无用的Key的对应的Entry移除掉!

  4. 在我们使用WeakHashMap的时候需要注意的是,尽量的防止,Key和Value使用同一个对象!如String是一个不变的对象,如果设置了一个“GOOD”的Key,也设置了一个“GOOD”的Value,String的对象是会被缓存的,所以其实Key和Value此时都是一个对象!但是Value是强引用,所以这个Key也永远无法被标记清除,就失去了WeakHashMap的意义了。在使用String作为WeakHashMap的Key的时候一定要小心,最好使用new String()包装一层,否则String会使用的是String缓冲池的数据,导致WeakHashMap的泄露!如果某些情况,Key必须和Value 相同,那么可以有两种方法解决!:第一种,从Key中深Copy元素,产生Value,此时Key和Value,是不同的元素!第二种,对Value也使用一个WeakReference!

WeakHashMap的大体思路是,Key是一个WeakHashMap,当Key可以回收的时候,我们就通过Key找到相应的Entry,然后移除Value。当每次Put,GET,Size相关操作的时候,就会去检查是否有相应的Key可以回收。

我们直接来看WeakHashMap里最重要的检测回收的方法:

private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {  //通过poll方法,不断轮询Queue的元素
            synchronized (queue) {
                @SuppressWarnings("unchecked")
                    Entry e = (Entry) x;
                int i = indexFor(e.hash, table.length);     //通过hash找到index
                // WeakHashMap和HashMap是一样的,都有BuUket的概念,Buket之下是链表的概念dou'yo
                Entry prev = table[i];     
                Entry p = prev;
                while (p != null) {
                    Entry next = p.next;
                    if (p == e) {
                        if (prev == e)
                            table[i] = next;    
                            // p == e && pre == e 那么久表示是第一个元素
                        else
                            prev.next = next;   //不是第一个元素
                        // Must not null out e.next;
                        // stale entries may be in use by a HashIterator
                        //上面的作用就是删除链表中的e这个元素。
                        
                        e.value = null; // Help GC //将e的Value设置为null
                        size--; 
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
    }

你可能感兴趣的:(RefenceQueue的源码解析,以及WeakHashMap的源码分析)