java 对象引用 方法 java对象的引用

Java对象的引用类型有强引用，软引用，弱引用，虚引用和FinalReference,提供这几种引用类型的主要目的：

1.程序员可以通过不同的引用方式决定某些对象的生命周期；
2.利用JVM的垃圾回收机制，对象可达性分析，进行不同策略的垃圾回收；
3.合理的利用软，弱，虚引用可以避免内存溢出等风险。

     下面来详细谈谈这几种类型引用，首先需要了解一下对象的可达性，java对象不同生命周期，可达性的状态也是不一样，具体分为强可达，软可达，和弱可达，幻象可达和不可达（不可达基本上可以直接回收了），这些可达性状态基本上对应着对象引用的类型关系 ，jvm依赖对象可达性来进行垃圾回收的。

 

1.强引用

创建一个对象并把这个对象赋给一个引用变量

Object object = new Object();
String str = "hello";

     强引用有引用变量指向时永远不会被垃圾回收，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。

2.引用

     说一下Reference引用对象是后面提到的软，弱，虚，Final的基类，所以后面的几个引用类型都是基于它来扩展的，如果需要使用最好配合带ReferenceQueue的构造函数进行使用，Reference基于ReferenceQueue进行垃圾回收的。带queue的构造引用，垃圾回收过程中，该对象会经历Active->Pending（等待GC）->Enqueued(入队)->Inactive（完全回收）的状态，这个对象放到队列里的作用就是当我们使用引用的时候，可以查询这个队列，来判断对象内存是否被回收。具体可以看一下源码。下面就介绍具体的子类引用类型。

3.软引用

      如果一个对象具有软引用，内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，才会被GC。只要垃圾回收器没有回收它，该对象就可以被程序使用。

3.1 简单使用

public class SoftReferenceTest {
    public static void main(String[] args) {
        SoftReference softReference = new SoftReference(new String("object"));
        String softObject = (String) softReference.get();
    }
}

 

3.2 软引用的特点

     SoftReference的特点,在垃圾线程对这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。另外，一旦垃圾线程回收该Java对象之 后，get()方法将返回null。Java虚拟机的垃圾收集线程对软可及对象和其他一般Java对象进行了区别对待，软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。

具体策略：垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软可及对象，而且虚拟机会尽可能优先回收长时间闲置不用的软可及对象，对那些刚刚构建的或刚刚使用过的“新”软可反对象会被虚拟机尽可能保留。

3.3 配合ReferenceQueue

      作为一个Java对象，SoftReference对象除了具有保存软引用的特殊性之外，也具有Java对象的一般性。所以，当软可及对象被回收之后，虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值，需要一个适当的清除机制，避免大量SoftReference对象带来的内存泄漏。在java.lang.ref包里还提供了ReferenceQueue。当这个SoftReference所软引用的对象被垃圾收集器回收的同时，ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说，ReferenceQueue中保存的对象是Reference对象，而且是已经失去了它所软引用的对象的Reference对象。在任何时候，我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。利用这个方法，我们可以检查SoftReference软引用对象是否被回收。

@Test
public void testRefQueue() {
    ReferenceQueue queue = new ReferenceQueue();
    //创建一个软引用
    new SoftReference(new String("xxx"), queue);
    /**
     * GC后进行一次手动check，并清除
     */
    SoftReference remove = null;
    while ((remove = (SoftReference) queue.poll()) != null) {
        // 清除ref
        System.out.println("SoftReference 不为 null，这里进行手动清除");
        remove.clear();
    }
}

 

3.4 为什么需要使用软引用？

     在我们平时开发当中，如果我们希望对象尽可能的存在时间长一点，在内存允许的情况下，一些可缓冲的对象就可以使用软引用的方式进行持有对象，或者在一段时间内，该对象使用的频次比较多，过了热点时间，就不会被使用，这样我们可以大大减少没必要的对象再次创建，就像使用缓存一样。所以软引用可用来实现内存敏感的高速缓存，使用软引用能防止内存泄露，增强程序的健壮性。软引用和弱引用都可以解决OOM问题。
例如：软引用的一个使用例子，维护一个用户缓存

/**
 * @author zhangzuizui
 * @date 2018/6/27 18:27
 */
public class UserCache {

    private static UserCache userCache;
    // 用于Chche内容的存储
    private ConcurrentHashMap<String,UserRef> userRefsMap;
    // 垃圾Reference的队列
    private ReferenceQueue<User> queue;

    private class UserRef extends SoftReference<User> {
        private String name = "zzz";

        public UserRef(User user, ReferenceQueue<User> queue) {
            super(user, queue);
            name = user.getName();
        }
    }

    // 取得缓存器实例
    public static UserCache getInstance() {
        if (userCache == null) {
            userCache = new UserCache();
        }
        return userCache;
    }
    // 构建一个缓存器实例
    private UserCache() {
        userRefsMap = new ConcurrentHashMap<>();
        queue = new ReferenceQueue<User>();
    }


    // 以软引用的方式对一个User对象的实例进行引用并保存该引用
    private void cacheUser(User user) {
        cleanCache();// 清除垃圾引用
        UserRef ref = new UserRef(user, queue);
        userRefsMap.put(user.getName(), ref);
    }

    // 依据所指定的userName，重新获取相应User对象的实例
    public User getUser(String userName) {
        User em = null;
        // 缓存中是否有该User实例的软引用，如果有，从软引用中取得。
        if (userRefsMap.containsKey(userName)) {
            UserRef ref = (UserRef) userRefsMap.get(userName);
            em = (User) ref.get();
        }
        // 如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，
        // 并保存对这个新建实例的软引用
        if (em == null) {
            em = new User(userName);
            System.out.println("new user userName=" + userName);
            this.cacheUser(em);
        }
        return em;
    }

    // 清除那些所软引用的User对象已经被回收的UserRef对象
    private void cleanCache() {
        UserRef ref = null;
        while ((ref = (UserRef) queue.poll()) != null) {
            userRefsMap.remove(ref.name);
        }
    }

    // 清除Cache内的全部内容
    public void clearCache() {
        cleanCache();
        userRefsMap.clear();
        System.gc();
        System.runFinalization();
    }
}

 

4. 弱引用

4.1 弱引用的特点

     弱引用WeakReference也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。弱引用也可以用来操作敏感缓存的对象，配合jvm的自身GC机制，来实现自动回收内存的效果，同样WeakReference也可以和引用队列一起使用。

public static void main(String[] args) {
        WeakReference<String> reference = new WeakReference<String>(new String("zzzz"));
        System.out.println(reference.get());
        //通知GVM回收资源
        System.gc();
        System.out.println(reference.get());
    }

      执行结果：第二个输出结果是null，这说明只要JVM进行垃圾回收，被弱引用关联的对象必定会被回收掉。不过要注意的是，这里所说的被弱引用关联的对象是指只有弱引用与之关联，如果存在强引用同时与之关联，则进行垃圾回收时也不会回收该对象（软引用也是如此）。
例如这样写：

String string = new String("zzzz")
WeakReference<String> reference = new WeakReference<String>(string);

这样两次System.out都会输出“zzzz”

 

4.2 为什么使用弱引用？

      一个长生命周期的对象如果对一个短生命周期的持有引用，那么这个短什么周期的对象一直无法被GC，这是出现内存泄露的一个原因，所以为了避免这种情况，我们可以运用WeakReference来持有该对象的引用，这样就不会出现长生命周期的对象的持有导致内存溢出。比如HashMap持有很对Object对象，其中有短周期的对象可以替换成虚引用。WeakHashMap就是运WeakReference实现的,从它entry子类中可以看出，它的key是WeakReference包裹住的。当这个key对象本身不再被使用时，伴随着GC的发生，会自动把该key对应的entry都在Map中清除掉。

 

5. 虚引用

5.1 虚引用的特点

      虚引用（PhantomReference）和前面的软引用、弱引用不同，它并不影响对象的生命周期。如果一个对象与虚引用关联，phantomReference.get()都是null，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。

5.2 虚引用的作用

      PhantomReference主要作为其指向的referent被回收时的一种通知机制，它就是利用上文讲到的ReferenceQueue实现的。当referent被gc回收时，可以通过这个通知机制来做额外的清场工作。因此有些情况可以用PhantomReference 代替finalize()，做资源释放更明智。

public static void main(String[] args) {
        ReferenceQueue<String> queue = new ReferenceQueue<String>();
        PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
        System.out.println(pr.get());
    }

 

6. FinalReference

      FinalReference 引用类型主要是为虚拟机提供的，提供对象被gc前需要执行finalize方法的对象 的机制。只是把访问权限改为package,因此我们是无法直接使用，jVM会对那些实现了Object中finalize()方法的类实例化一个对应的FinalReference，关于具体的细节有兴趣大家可以去看一下Finalizer的源码；
,其中包括Finalizer对象初始化守护线程，jvm注册Finalizer对象（实例化FinalReference），GC后入ReferenceQueue队列，并通知FinalizerThread去消费等操作。关于finalize方法的使用可以和该引用和串起来思考，后边有必要再总结一篇关于finalize的文章。

 

7. 打印GC引用日志：

-XX:+PrintGCDetails
0.194: [GC (System.gc()) 0.196: [SoftReference, 0 refs, 0.0000125 secs]0.196: [WeakReference, 11 refs, 0.0000064 secs]0.196: [FinalReference, 37 refs, 0.0000138 secs]0.196: [PhantomReference, 0 refs, 0 refs, 0.0000058 secs]0.196: [JNI Weak Reference, 0.0000417 secs]
0.196: [Full GC (System.gc()) 0.197: [SoftReference, 0 refs, 0.0000115 secs]0.197: [WeakReference, 3 refs, 0.0000071 secs]0.197: [FinalReference, 0 refs, 0.0000077 secs]0.197: [PhantomReference, 0 refs, 0 refs, 0.0000074 secs]0.197: [JNI Weak Reference, 0.0000276 secs]

 

8. 总结

      通过对SoftReference，WeakReference，PhantomReference，FinalReference 的介绍，可以看出JDK提供这些类型的reference 主要是用来和GC交互的，根据reference的不同，让JVM采用不同策略来进行对对象的回收(reclaim)。softly-reachable的referent在保证在OutOfMemoryError之前回收对象，weakly-reachable的referent在发生GC时就会被回收，finalizer型的reference 主要提供GC前对referent进行finalize执行机制。同时这些reference和referenceQueue在一起提供通知机制，PhantomReference的作用就是仅仅就是提供对象回收通知机制，Finalizer借助这种机制实现referent的finalize执行，SoftReference、WeakReference也可以配合referenceQueue使用，实现对象回收通知机制。