Java中引用和动态代理的示例分析

这篇文章主要介绍了Java中引用和动态代理的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

创新互联公司成立以来不断整合自身及行业资源、不断突破观念以使企业策略得到完善和成熟，建立了一套“以技术为基点，以客户需求中心、市场为导向”的快速反应体系。对公司的主营项目，如中高端企业网站企划 / 设计、行业 / 企业门户设计推广、行业门户平台运营、手机APP定制开发、手机网站制作、微信网站制作、软件开发、服务器机柜租用等实行标准化操作，让客户可以直观的预知到从创新互联公司可以获得的服务效果。

JDK中的引用类型

不同引用类型对GC行为的影响

引用类型的实现

ThreadLocal对弱引用的使用

动态代理对弱引用的实现

虚引用如何导致内存泄漏

JDK中「引用（Reference）」的类型

Java的所有运行逻辑都是基于引用的，其形态类似于不可变的指针，所以在Java中会有一些很绕的概念，比如说，Java中函数的传参是值传递，但这里所说的值，其实是引用的值，所以你可以通过一个函数的参数来修改其对象的值。另一方面，Java中还存在一些基本数据类型，它们没有引用，传递的是真实的值，所以不能在函数内部修改参数的值。

关于引用，Java中有这样几种：

1.强引用

所有对象的引用默认为强引用，普通代码中，赋值语句之间传递的都是强引用，如果一个对象可以被某个线程（活着的，下同）通过强引用访问到，则称之为强可达的（StronglyReachable）。

强可达的对象不会被GC回收。

2.软引用（SoftReference）

当一个对象不是强可达的，但可以被某个线程通过软引用访问到，则称之为软可达的（SoftlyReachable）。

软可达的对象的引用只有在内存不足时会被清除，使之可以被GC回收。在这一点上，JVM是不保证具体什么时候清除软引用，但可以保证在OOM之前会清除软可达的对象。同时，JVM也不保证软可达的对象的回收顺序，但OracleJDK的文档中提到，最近创建和最近使用的软可达对象往往会最后被回收，与LRU类似。

关于软可达的对象何时被回收，可以参考Oracle的文档。

3.弱引用（WeakReference）

当一个对象不是强可达的，也不是软可达的，但可以被某个线程通过弱引用访问到，则称之为弱可达的（WeaklyReachable）。

弱引用是除了强引用之外，使用最广泛的引用类型，它的特性也更简单，当一个对象是弱可达时，JVM就会清除这个对象上的弱引用，随后对这个对象进行回收动作。

4.虚引用（PhantomReference）

当一个对象，通过以上几种可达性分析都不可达，且已经finalized，但有虚引用指向它，则它是虚可达的（PhantomReachable）。

虚引用是行为最诡异，使用方法最难的引用，后边会讲到。

虚引用不会影响GC，它的get()方法永远返回null，唯一的用处就是在GCfinalize一个对象之后，它会被放到指定的队列中去。关于这个队列会在下边说明。

不同GC行为背后的原理

JVMGC的可达性分析

JVM的GC通过可达性分析来判断一个对象是否可被回收，其基本思路就是以GCRoots为起点遍历链路上所有对象，当一个对象和GCRoots之间没有任何的直接或间接引用相连时，就称之为不可达对象，则证明此对象是不可用的。

而进一步，Java中又定义了如上所述的4种不同的可达性，用来实现更精细的GC策略。

Finalaze和ReferenceQueue

对于普通的强引用对象，如果其变成不可达之后，通常GC会进行Finalize（Finalize主要目的是让用户可以自定义释放资源的过程，通常是释放本地方法中使用的资源），然后将它的对象销毁回收，但对于本文中讨论的3种引用，还有可能在这个过程中做一些别的事情：

GC根据约定的规则来决定是否清除这些引用

这方面上一节已经讲过了，每个引用类型都有约定的处理规则。

如果它们注册了引用队列，在Finalize对象后，将引用的对象放入队列。

主要用来使开发者可以得到对象被销毁的通知，当然，如虚引用这样的，其引用不会自动被清除，所以它可以阻止其所引用的对象被回收。

引用（java.lang.ref.Reference）对象的状态

这里所说的「引用对象」指的是由类java.lang.ref.Reference生产的对象，这个对象上保持了「需要特殊处理的」对「目标对象」的引用。

引用对象有4种状态，根据它与其注册的队列的关系，分为以下4种：

Active

引用对象的初始状态，表示GC要按照特殊的逻辑来处理这个对象，大致方法就是按照上一节提到的。

Pending

如果一个引用对象，其注册了队列，在入队之前，会进入这个状态。

Enqueued

一个引用对象入队后，进入这个状态。

Inactive

一个引用对象出队后，或者没有注册队列，其队列是一个特殊的对象java.lang.ref.ReferenceQueue.NULL，表示这个对象已经没有用了。

几种引用的实际应用

日常开发工作中，用到除强引用之外的引用的可能性很小，只有在处理一些性能敏感的逻辑时，才需要考虑使用这些特殊的引用，下面就举几个相关的实际例子，分析其使用场景。

软引用

弱引用的使用比较简单，如Guava中的LocalCache中就是用了SoftReference来做缓存。

弱引用

弱引用是使用的比较多的，从上文的描述可知：对于一个「目标对象A」，如果还有强引用指向它，那么从一个弱引用就可以访问到A，一旦没有强引用指向它，那么就可以认为，从这个弱引用就访问不到A了（实际情况可能会有偏差）。

根据这个特点，JDK中注释说到，弱引用通常用来做映射表（canonicalizingmapping），总结下来映射表有这样2个特点：

如果表中的Key（或者Value）还存在强引用，则可以通过Key访问到Value，反之则访问不到

换句话说，只要有原始的Key，就能访问到Value。

映射表本身不会影响其中Key或者Value的GC

在JDK中有很多个地方使用了它的这个特点，下面是2个具有代表性的实例。

1.ThreadLocal

ThreadLocal的原理比较简单，线程中保持了一个以ThreadLocal为Key的ThreadLocal.ThreadLocalMap对象threadLocals，其中的Entry如代码1中所示：

//代码1
static class Entry extends WeakReference> {
  /** The value associated with this ThreadLocal. */
  Object value;
  //其保持了对作为Key的ThreadLocal对象的弱引用
  Entry(ThreadLocal k, Object v) {
    super(k);
    value = v;
  }
}

其引用关系如下图所示：

ThreadLocal中的引用关系

从上图可以看出，当引用2被清除之后（ThreadLocal对象不再使用），如果引用4为强引用，则不论引用1是否还存在，只要Thread对象还没死，则对象1和对象2永远不会被释放。

2.动态代理

动态代理是Java世界一个十分重要的特性，对于需要做AOP的业务逻辑十分重要。JDK本身提供了基于反射的动态代理机制，其原理大致是要通过预先定义的接口（interface）来动态的生成代理类，并将之代理到InvocationHandler的实例上去。JDK的动态代理使用起来很简单，如下代码2中所示：

//代码2
package me.lk;

import java.lang.reflect.*;

public class TestProxy {
  /**
   * 两个预定义的需要被代理的接口
   */
  public static interface ProxiedInterface {

    void proxiedMethod();
  }
  public static interface ProxiedInterface2 {

    void proxiedMethod2();
  }

  /**
   * 真正的处理逻辑
   */
  public static class InvoHandler implements InvocationHandler {

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("in proxy:" + method.getName());
      //其他逻辑
      System.out.println("in proxy end");
      return null;
    }
    
  }
  public static void main(String[] args) {
    InvoHandler ih = new InvoHandler();
    ProxiedInterface proxy = (ProxiedInterface) Proxy.newProxyInstance(TestProxy.class.getClassLoader(), new Class[]{ProxiedInterface.class, ProxiedInterface2.class}, ih);
    proxy.proxiedMethod();
    ProxiedInterface2 p = (ProxiedInterface2) proxy;
    p.proxiedMethod2();
  }

}

动态代理的实现原理

关于Java中的动态代理，我们首先需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。

参阅：Java设计模式之代理模式原理及实现代码分享

其实现原理其实也很简单，就是在方法Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)中动态生成一个「实现了interfaces中所有接口」并「继承于Proxy」的代理类，并生成相应的对象。

//代码3
public static Object newProxyInstance(ClassLoader loader,
                     Class[] interfaces,
                     InvocationHandler h)
    throws IllegalArgumentException
  {
	Objects.requireNonNull(h);
	final Class[] intfs = interfaces.clone();
	//验证真实调用者的权限
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
		checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
	}
	//查询或生成代理类
	Class cl = getProxyClass0(loader, intfs);
	//验证调用者对代理类的权限，并生成对象
	。。。省略代码
}
private static Class getProxyClass0(ClassLoader loader,
                    Class... interfaces) {
	if (interfaces.length > 65535) {
		throw new IllegalArgumentException("interface limit exceeded");
	}
	// 通过缓存获取代理类
	return proxyClassCache.get(loader, interfaces);
}

生成动态类的逻辑在方法java.lang.reflect.Proxy.ProxyClassFactory.apply(ClassLoader, Class[])，代码如下：

//代码4
@Override
public Class apply(ClassLoader loader, Class[] interfaces) {

  Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
  //验证接口，验证接口是否重复，验证loader对接口的可见性
  
  //生成包名和修饰符

  //生成类
  byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
    proxyName, interfaces, accessFlags);
  try {
    return defineClass0(loader, proxyName,
              proxyClassFile, 0, proxyClassFile.length);
  } catch (ClassFormatError e) {
    /*
     * 生成失败
     */
    throw new IllegalArgumentException(e.toString());
  }
}

动态代理中的缓存策略

为了更高效的使用动态代理，Proxy类中采用了缓存策略（代码3中的proxyClassCache ）来缓存动态生成的代理类，由于这个缓存对象是静态的，也就是说一旦Proxy类被加载，proxyClassCache 很可能永远不会被GC回收，然而它必须要保持对其中的ClassLoader和Class的引用，如果这里使用强引用，则它们也随着proxyClassCache 永远不会被GC回收。

不再使用的类和类加载器如果无法被GC，其内存泄漏的风险很大。所以WeakCache中设计为，「传入的类加载器」和「生成的代理类」为弱引用。

类和类加载器是相互引用的，而类加载器的内存泄漏可能会带来很严重的问题，有兴趣可以去看这篇文章：Reloading Java Classes 201: How do ClassLoader leaks happen?

//代码5
/**
 * a cache of proxy classes
 */
//ClassLoader  用来加载预定义接口（interface）和生成代理类的类加载器
//Class[]   预定义接口（interface）
//Class    生成的代理类
private static final WeakCache[], Class>
  proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

/**
 * CacheKey containing a weakly referenced {@code key}. It registers
 * itself with the {@code refQueue} so that it can be used to expunge
 * the entry when the {@link WeakReference} is cleared.
 */
private static final class CacheKey extends WeakReference 

/**
 * A {@link Value} that weakly references the referent.
 */
private static final class CacheValue
  extends WeakReference implements Value

从代码5中可以看出，WeakCache对象中保持了对ClassLoader（包装为CacheKey）和代理类（包装为CacheValue）的弱引用，所以当此类加载器和代理类不再被强引用时，它们就会被回收。

存在的问题

然而，WeakCache的实现是有问题的，在java.lang.reflect.WeakCache.reverseMap和java.lang.reflect.WeakCache.valueFactory中的状态在极限情况下可能会出现不同步，导致一个代理类被调用java.lang.reflect.Proxy.isProxyClass(Class)的返回值不正确。具体可以参考RaceConditioninjava.lang.reflect.WeakCache。

不过这个问题在JDK9中已经不存在了。

关于虚引用的GC行为

在上一节，并没有列出虚引用的使用场景，因为它的使用场景十分单一。PhantomReference设计的目的就是可以在对象被回收之前收到通知（通过注册的队列），所以它没有不含注册队列的构造器（只有publicPhantomReference(Treferent,ReferenceQueueq)，但你仍可以传null进去），但这种场景在JDK里并没有出现，也很少有开发者使用它。

从PhantomReference类的源代码可知，你永远无法通过它获取到它引用的那个对象（其get()方法永远返回null），但是它又可以阻止其引用的目标对象被GC回收。从上文可知，通常一个不可达（强不可达、软不可达、弱不可达）的对象会被finalize，然后被回收。但如果它在被回收前，GC发现它仍然是虚可达，那么它就不会回收这块内存，而这块内存又不能被访问到，那么这块内存就泄漏了。

想要虚引用的「目标对象」被回收，必须让「引用对象」本身不可达，或者显式地清除虚引用。所以如果使用不当，很可能会造成内存泄漏，这也是它使用范围不广的原因之一。

代码6演示了这3种引用分别的GC行为：

//代码6
private static List> phantomRefs = new ArrayList<>();
private static List> weaks = new ArrayList<>();
private static List> softs = new ArrayList<>();

public static void testPhantomRefLeakOOM() {
  while(true) {
    //生成一个占用10M的内存的对象
    Byte[] bytes = new Byte[1024 * 1024 * 10];
    //使用软引用存储
//  softs.add(new SoftReference