java三个引用类型

四种引用类型

为东港等地区用户提供了全套网页设计制作服务，及东港网站建设行业解决方案。主营业务为成都网站建设、做网站、东港网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

所以在 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱。

一，强引用

Java中默认声明的就是强引用，比如：

Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收

obj = null; //手动置null

只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了

二，软引用

软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。

在 JDK1.2 之后，用java.lang.ref.SoftReference类来表示软引用。

下面以一个例子来进一步说明强引用和软引用的区别：

在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx3M，将 JVM 的初始内存设为2M，最大可用内存为 3M。

首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常

public class TestOOM {

public static void main(String[] args) {

testStrongReference();

}

private static void testStrongReference() {

// 当 new byte为 1M 时，程序运行正常

byte[] buff = new byte[1024 * 1024 * 1];

}

}

但是如果我们将

byte[] buff = new byte[1024 * 1024 * 1];

替换为创建一个大小为 2M 的字节数组

byte[] buff = new byte[1024 * 1024 * 2];

则内存不够使用，程序直接报错，强引用并不会被回收

接着来看一下软引用会有什么不一样，在下面的示例中连续创建了 10 个大小为 1M 的字节数组，并赋值给了软引用，然后循环遍历将这些对象打印出来。

public class TestOOM {

private static ListObject list = new ArrayList();

public static void main(String[] args) {

testSoftReference();

}

private static void testSoftReference() {

for (int i = 0; i 10; i++) {

byte[] buff = new byte[1024 * 1024];

SoftReferencebyte[] sr = new SoftReference(buff);

list.add(sr);

}

System.gc(); //主动通知垃圾回收

for(int i=0; i list.size(); i++){

Object obj = ((SoftReference) list.get(i)).get();

System.out.println(obj);

}

}

}

打印结果：

我们发现无论循环创建多少个软引用对象，打印结果总是只有最后一个对象被保留，其他的obj全都被置空回收了。

这里就说明了在内存不足的情况下，软引用将会被自动回收。

值得注意的一点 , 即使有 byte[] buff 引用指向对象, 且 buff 是一个strong reference, 但是 SoftReference sr 指向的对象仍然被回收了，这是因为Java的编译器发现了在之后的代码中, buff 已经没有被使用了, 所以自动进行了优化。

如果我们将上面示例稍微修改一下：

private static void testSoftReference() {

byte[] buff = null;

for (int i = 0; i 10; i++) {

buff = new byte[1024 * 1024];

SoftReferencebyte[] sr = new SoftReference(buff);

list.add(sr);

}

System.gc(); //主动通知垃圾回收

for(int i=0; i list.size(); i++){

Object obj = ((SoftReference) list.get(i)).get();

System.out.println(obj);

}

System.out.println("buff: " + buff.toString());

}

则 buff 会因为强引用的存在，而无法被垃圾回收，从而抛出OOM的错误。

如果一个对象惟一剩下的引用是软引用，那么该对象是软可及的（softly reachable）。垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。

三，弱引用

弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。

我们以与软引用同样的方式来测试一下弱引用：

private static void testWeakReference() {

for (int i = 0; i 10; i++) {

byte[] buff = new byte[1024 * 1024];

WeakReferencebyte[] sr = new WeakReference(buff);

list.add(sr);

}

System.gc(); //主动通知垃圾回收

for(int i=0; i list.size(); i++){

Object obj = ((WeakReference) list.get(i)).get();

System.out.println(obj);

}

}

打印结果：

可以发现所有被弱引用关联的对象都被垃圾回收了。

四，虚引用

虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。

public class PhantomReferenceT extends ReferenceT {

/**

* Returns this reference object's referent. Because the referent of a

* phantom reference is always inaccessible, this method always returns

* codenull/code.

*

* @return codenull/code

*/

public T get() {

return null;

}

public PhantomReference(T referent, ReferenceQueue? super T q) {

super(referent, q);

}

}

那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？

五，引用队列（ReferenceQueue）

引用队列可以与软引用、弱引用以及虚引用一起配合使用，当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施。

java中的虚引用，有什么作用？

个人理解：深入理解JAVA虚拟机一书中有这样一句描述：“为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知”。所以虚引用更多的是用于对象回收的监听，能做的功能如下：

重要对象回收监听 进行日志统计

系统gc监听 因为虚引用每次GC都会被回收，那么我们就可以通过虚引用来判断gc的频率，如果频率过大，内存使用可能存在问题，才导致了系统gc频繁调用

参考Java幽灵引用的作用

Java中的强引用，软引用，弱引用，虚引用有什么用

强引用：

只要引用存在，垃圾回收器永远不会回收

Object obj = new Object();

//可直接通过obj取得对应的对象 如obj.equels(new Object());

而这样 obj对象对后面new Object的一个强引用，只有当obj这个引用被释放之后，对象才会被释放掉，这也是我们经常所用到的编码形式。

软引用：

非必须引用，内存溢出之前进行回收，可以通过以下代码实现

Object obj = new Object();

SoftReferenceObject sf = new SoftReferenceObject(obj);

obj = null;

sf.get();//有时候会返回null

这时候sf是对obj的一个软引用，通过sf.get()方法可以取到这个对象，当然，当这个对象被标记为需要回收的对象时，则返回null；

软引用主要用户实现类似缓存的功能，在内存足够的情况下直接通过软引用取值，无需从繁忙的真实来源查询数据，提升速度；当内存不足时，自动删除这部分缓存数据，从真正的来源查询这些数据。

弱引用：

第二次垃圾回收时回收，可以通过如下代码实现

Object obj = new Object();

WeakReferenceObject wf = new WeakReferenceObject(obj);

obj = null;

wf.get();//有时候会返回null

wf.isEnQueued();//返回是否被垃圾回收器标记为即将回收的垃圾

弱引用是在第二次垃圾回收时回收，短时间内通过弱引用取对应的数据，可以取到，当执行过第二次垃圾回收时，将返回null。

弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。

虚引用：

垃圾回收时回收，无法通过引用取到对象值，可以通过如下代码实现

Object obj = new Object();

PhantomReferenceObject pf = new PhantomReferenceObject(obj);

obj=null;

pf.get();//永远返回null

pf.isEnQueued();//返回是否从内存中已经删除

虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null，因此也被成为幽灵引用。

虚引用主要用于检测对象是否已经从内存中删除。

Java中弱引用和软引用的区别以及虚引用和强引用介绍

Java中弱引用VS软引用

Java中有如下四种类型的引用：

1.强引用(Strong Reference)

2.弱引用(WeakReference)

3.软引用(SoftReference)

4.虚引用(PhantomReference)

强引用是我们在编程过程中使用的最简单的引用，如代码String s=”abc”中变量s就是字符串对象”abc”的一个强引用。任何被强引用指向的对象都不能被垃圾回收器回收，这些对象都是在程序中需要的。弱引用使用java.lang.ref.WeakReference class 类来表示，你可以使用如下代码创建弱引用：

复制代码代码如下:

Counter counter = new Counter(); // strong reference - line 1

WeakReferenceCounter weakCounter = new WeakReferenceCounter(counter); //weak reference

counter = null; // now Counter object is eligible for garbage collection

现在只要你给强引用对象counter赋空值null,该对象就可以被垃圾回收器回收。因为该对象此时不再含有其他强引用，即使指向该对象的弱引用weakCounter也无法阻止垃圾回收器对该对象的回收。相反的，如果该对象含有软引用，Counter对象不会立即被回收，除非JVM需要内存。Java中的软引用使用java.lang.ref.SoftReference类来表示，你可以使用如下代码创建软引用：

复制代码代码如下:

Counter prime = new Counter(); // prime holds a strong reference – line 2

SoftReference soft = new SoftReference(prime) ; //soft reference variable has SoftReference to Counter Object created at line 2

prime = null; // now Counter object is eligible for garbage collection but only be collected when JVM absolutely needs memory

强引用置空之后，代码的第二行为对象Counter创建了一个软引用，该引用同样不能阻止垃圾回收器回收对象，但是可以延迟回收，与弱引用中急切回收对象不同。鉴于软引用和弱引用的这一区别，软引用更适用于缓存机制，而弱引用更适用于存贮元数据。另一个使用弱引用的例子是WeakHashMap，它是除HashMap和TreeMap之外，Map接口的另一种实现。WeakHashMap有一个特点：map中的键值(keys)都被封装成弱引用，也就是说一旦强引用被删除，WeakHashMap内部的弱引用就无法阻止该对象被垃圾回收器回收。

虚引用是java.lang.ref package包中第三种可用的引用，使用java.lang.ref.PhantomReference类来表示。拥有虚引用的对象可以在任何时候被垃圾回收器回收。和弱引用和软引用相似，你可以通过如下代码创建虚引用：

复制代码代码如下:

DigitalCounter digit = new DigitalCounter(); // digit reference variable has strong reference – line 3

PhantomReference phantom = new PhantomReference(digit); // phantom reference to object created at line 3

digit = null;

一旦移除强引用，第三行的DigitalCounter对象可以在任何时候被垃圾回收器回收。因为只有一个虚引用指向该对象，而虚引用无法阻止垃圾回收器回收对象。

除了了解弱引用、软引用、虚引用和WeakHashMap，还需要了解ReferenceQueue。在创建任何弱引用、软引用和虚引用的过程中你可以通过如下代码提供引用队列ReferenceQueue：

复制代码代码如下:

ReferenceQueue refQueue = new ReferenceQueue(); //reference will be stored in this queue for cleanup

DigitalCounter digit = new DigitalCounter();

PhantomReferenceDigitalCounter phantom = new PhantomReferenceDigitalCounter(digit, refQueue);

引用实例被添加在引用队列中，你可以再任何时候通过查询引用队列回收对象。一个对象的生命周期可以通过下图进行描述：

这就是Java中弱引用和软引用的区别。我们还学到了一些基本的引用类：弱引用、软引用、虚引用以及WeakHashMap和WeakHashMap。总之，合理的使用引用可以帮助垃圾回收器更好的管理Java内存。

当前标题：java虚引用什么代码好,java强软弱虚引用
URL地址：http://hbruida.cn/article/hoesdc.html