JAVA四种引用方式-上篇

转载自：https://www.2cto.com/kf/201403/285767.html

1.引用的基本概念

1.1、强引用
当我们使用new 这个关键字创建对象时被创建的对象就是强引用，如Object object = new Object() 这个Object()就是一个强引用了，如果一个对象具有强引用。垃圾回收器就不会去回收有强引用的对象。如当jvm内存不足时，具备强引用的对象， 虚拟机 宁可会报内存空间不足的异常来终止程序，也不会靠垃圾回收器去回收该对象来解决内存。
1.2、软引用
如果一个对象具备软引用，如果内存空间足够，那么垃圾回收器就不会回收它，如果内存空间不足了，就会回收该对象。当然没有被回收之前，该对象依然可以被程序调用。
1.3、弱引用
如果一个对象只具有弱引用，只要垃圾回收器在自己的内存空间中线程检测到了，就会立即被回收，对应内存也会被释放掉。相比软引用弱引用的生命周期要比软引用短很多。不过，如果垃圾回收器是一个优先级很低的线程，也不一定会很快就会释放掉软引用的内存。
1.4、虚引用
如果一个对象只具有虚引用，那么它就和没有任何引用一样，随时会被jvm当作垃圾进行回收。 
2、jdk引用级别
jdk1.2以前是没有这些概念，在jdk1.2以后的版本中才开始引入了引用的四种级别依次是，强引用、软引用、弱引用和虚引用。
jdk中java.lang.ref.Reference类就是java引用抽象基类，reference定义了引用对象的操作。当然该类是与垃圾回收器配合使用的。

3、引用和队列的使用
强引用一般是不会和队列一起使用的，这个过滤掉。
软引用可以和一个引用队列来联合使用，一般软引用可以用来实现内存敏感的高速缓存，如果软引用的所引用的对象被垃圾回收，java虚拟机就会把引用入到与之关联的引用队列中去。
弱引用和队列使用在一起，如果弱引用被所引用的对象回收了，java虚拟机就会把这个弱引用加入到关联的队列中去；
虚引用，在java虚拟机回收虚引用时，会把这个虚引用放到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经引用了虚引用，来了解引用对象是否要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么可以在所引用的对象内存前，采取一些逻辑处理。

4、jdk中的引用实现类
代表软引用的类：java.lang.ref.SoftReference
代表弱引用的类：java.lang.ref.WeakReference
代表虚引用的类：java.lang.ref.PhantomReference
他们同时继承了：java.lang.ref.Reference
引用队列：java.lang.ref.ReferenceQueue,这个引用队列是可以三种引用类型联合使用的，以便跟踪java虚拟机回收所引用对象的活动。
5、引用例子

如何实现一个软引用？

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

/** * 实现一个软引用 */ public static  void testSoftReference(){ //创建一个强引用Test String str = new String( "Test" ); //创建一个引用队列 ReferenceQueue<string> rq = new ReferenceQueue<string>(); //实现一个软引用，将强引用类型str和是实例化的rq放到软引用实现里面 SoftReference<string> srf = new SoftReference<string>(str,rq); //通过软引用get方法获取强引用中创建的内存空间Test值 System.out.println(srf.get()); //程序执行下gc现在jvm的内存空间还有很多所以gc不会回收str的对象 System.gc(); //所以这里执行get还是会打印Test的 System.out.println(srf.get());   }</string></string></string></string>

执行完这个软引用，那么jvm堆栈区会是什么样呢？

如何实现一个弱引用呢？

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

/** * 实现一个弱引用 */ public static  void testWeakReference(){ String str = new String( "Test" ); ReferenceQueue<string> rq = new ReferenceQueue<string>(); //实现一个弱引用，将强引用类型str和是实例化的rq放到弱引用实现里面 WeakReference<string> wrf = new WeakReference<string>(str,rq); //给str给值为null。 然后再通过WeakReference弱引用的get()方法获得Test对象的引用 str = null ; //程序多执行gc，提高gc执行线程频率来回收对象。 System.gc(); //假如它还没有被垃圾回收，那么接下来在第执行wrf.get()方法会返回Test对象的引用，并且使得这个对象被str1强引用。 //再接下来在行执行rq.poll()方法会返回null，因为此时引用队列中没有任何引用。 String str1 = wrf.get(); System.out.println(str1); //ReferenceQueue的poll()方法用于返回队列中的引用，如果没有则返回null。 Reference<string> ref= (Reference<string>) rq.poll(); System.out.println( "弱引用已消失" +ref); if (ref!= null ){ System.out.println(ref.get()); } }</string></string></string></string></string></string>

6、综合实例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

/**   * 创建一个引用对象ref   * @author TianYou   */ public class RefObject { private static final int size = 80000 ; //创建一个Object数组，这样会占用很大的内存空间。预计大概会有640k左右的内存被占用 private Object[] object = new Object[size]; private String refId; public RefObject(String id){ this .refId = id ; } public String RefIdToString(){ return refId; } public void findName(){ System.out.println( "findName=" +refId); }   }   测试类 package reference; import java.lang.ref.PhantomReference; import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; import java.lang.ref.SoftReference; import java.lang.ref.WeakReference; import java.util.HashSet; import java.util.Set; /**   * 测试引用   * @author TianYou   */ public class TestReference { //创建一个引用队列 private static ReferenceQueue<refobject> rq = new ReferenceQueue<refobject>(); private static int size = 10 ; /** * 验证队列 */ public static void checkQueue(){ Reference<!--? extends RefObject--> ref = rq.poll(); if ( null != ref) System.out.println( "In queue: " +ref+ " : " +ref.get()); }   /** * 创建10个RefObject对象\以及10个软引用 */ public static void testSoftReference(){ System.out.println( "--------执行软引用开始-------" ); Set<softreference<refobject>> sa = new HashSet<softreference<refobject>>(); for ( int i = 0 ; i < size; i++) { SoftReference<refobject> ref= new SoftReference<refobject>( new RefObject( "SoftReference " + i), rq); System.out.println( "Just created: " +ref.get()); sa.add(ref); } System.gc(); checkQueue(); System.out.println( "--------执行软引用结束-------" ); }   /** * 创建10个Grocery对象以及10个弱引用 */ public static void testWeakReference(){ System.out.println( "--------执行弱引用开始-------" ); Set<weakreference<refobject>> wa = new HashSet<weakreference<refobject>>(); for ( int i = 0 ; i < size; i++) { WeakReference<refobject> ref= new WeakReference<refobject>( new RefObject( "WeakReference " + i), rq); System.out.println( "Just created: " +ref.get()); wa.add(ref); } System.gc(); checkQueue(); System.out.println( "--------执行软弱用结束-------" ); }   /** * 创建10个Grocery对象以及10个虚引用 */ public static void testPhantomReference(){ System.out.println( "--------执行虚引用开始-------" ); Set<phantomreference<refobject>> pa = new HashSet<phantomreference<refobject>>(); for ( int i = 0 ; i < size; i++) { PhantomReference<refobject>ref = new PhantomReference<refobject>( new RefObject( "PhantomReference " + i), rq); System.out.println( "Just created: " +ref.get()); pa.add(ref); } System.gc(); checkQueue(); System.out.println( "--------执行虚弱用结束-------" ); } public static void main(String args[]){ testSoftReference(); testWeakReference(); testPhantomReference(); } }</refobject></refobject></phantomreference<refobject></phantomreference<refobject></refobject></refobject></weakreference<refobject></weakreference<refobject></refobject></refobject></softreference<refobject></softreference<refobject></refobject></refobject>

在综合实例这里可以看到，三个引用依次都创建了10次，都包含了一个refobject对象，从打印结果可以明确看出，虚引用基本是形同虚设，它引用的对象随时会被垃圾回收器回收，具有弱引用的对象拥有的稍微长一点的生命周期，但垃圾回收器执行回操作时，依然有可能回被垃圾回收器回收，生命周期长的还是软引用。但在虚拟机内存不足的情况下依然会被回收，所以可出这些引用的方式真的不适合在线上使用，否则在极度容易出现鼓掌而在排查时很难检测出结果。
7、弱引用的WeakHashMap
弱引用的jar路径java.util.WeakHashMap。它是弱引用为键实现的哈希表的map。在weakHashMap表某个键不正常时，将会自动移出那个不正常的键。如果对持有强引用的key，它就会一直存在。同时它也支持null key和null value。更精确地说，对于一个给定的key，其映射的存在并不阻止垃圾回收器对该key的回收，这就使该key可以被终止的，key被终止，然后垃圾回收器回收。回收某个key时，其条目从映射中也会被有效地移除，因此，该类的行为与其他的 Map 实现有所不同
接下来也看看实例。
创建一个key对象

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

public class Key { String id;         public Key(String id) {           this .id = id;       }       public String toString() {           return id;       }       public int hashCode() {           return id.hashCode();       }       public boolean equals(Object r) {           return (r instanceof Key) && id.equals(((Key) r).id);       }       public void finalize() {           System.out.println( "Finalizing Key " + id);       } } 创建一个value对象 public class Value { String id;       public Value(String id) {           this .id = id;       }       public String toString() {           return id;       }       public void finalize() {           System.out.println( "Finalizing Value " + id);       }  }   测试对象       import java.util.WeakHashMap; public class MapCache { public static void main(String[] args) throws Exception {           int size = 10000 ;          Key[] keys = new Key[size];          WeakHashMap<key,value> whm = new WeakHashMap<key,value>();           for ( int i = 0 ; i < size; i++) {               Key k = new Key(Integer.toString(i));               Value v = new Value(Integer.toString(i));               if (i % 5 == 0 )                   keys[i] = k; // 使Key对象持有强引用                whm.put(k, v); // 使Key对象持有弱引用           }           // 催促垃圾回收器工作           System.gc();          // 把CPU让给垃圾回收器线程           Thread.sleep( 8000 );       }  }   运行结果看出来 整出 5 的对象持有强引用被保留了下来</key,value></key,value>