锐客网

  1. 首页 > 生活百科 > it技术 > >

java软引用代码 jvm软引用

IT技术引用

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 关于强引用，软引用，弱引用和虚引用的区别与用法强引用：
String str = “abc”;
list.add(str);
软引用：
如果弱引用对象回收完之后，内存还是报警，继续回收软引用对象
弱引用：
如果虚引用对象回收完之后，内存还是报警，继续回收弱引用对象
虚引用：
虚拟机的内存不够使用，开始报警，这时候垃圾回收机制开始执行System.gc(); String s = “abc”;如果没有对象回收了，就回收没虚引用的对象
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虚拟机，碰到引用的问题，在此借鉴总结一下：
原文地址：
对象的强、软、弱和虚引用
在JDK 1.2以前的版本中，若一个对象不被任何变量引用 ， 那么程序就无法再使用这个对象 。也就是说，只有对象处于可触及（reachable）状态 ， 程序才能使用它 。从JDK 1.2版本开始，把对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期 。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用 。
⑴强引用（StrongReference）
强引用是使用最普遍的引用 。如果一个对象具有强引用，那垃圾回收器绝不会回收它 。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题 。ps：强引用其实也就是我们平时A a = new A()这个意思 。
⑵软引用（SoftReference）
如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了 ， 就会回收这些对象的内存 。只要垃圾回收器没有回收它，该对象就可以被程序使用 。软引用可用来实现内存敏感的高速缓存（下文给出示例） 。
软引用可以和一个引用队列（ReferenceQueue）联合使用 ， 如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中 。
⑶弱引用（WeakReference）
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期 。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否 ， 都会回收它的内存 。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象 。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收 ， Java虚拟机就会把这个弱引用加入到与之关联的引用队列中 。
⑷虚引用（PhantomReference）
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同 ， 虚引用并不会决定对象的生命周期 。如果一个对象仅持有虚引用 ， 那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收 。
虚引用主要用来跟踪对象被垃圾回收器回收的活动 。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用 。当垃圾回收器准备回收一个对象时 ， 如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中 。
ReferenceQueue queue = new ReferenceQueue ();
PhantomReference pr = new PhantomReference (object, queue);
程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收 。如果程序发现某个虚引用已经被加入到引用队列 ， 那么就可以在所引用的对象的内存被回收之前采取必要的行动 。
使用软引用构建敏感数据的缓存
1 为什么需要使用软引用
首先，我们看一个雇员信息查询系统的实例 。我们将使用一个Java语言实现的雇员信息查询系统查询存储在磁盘文件或者数据库中的雇员人事档案信息 。作为一个用户，我们完全有可能需要回头去查看几分钟甚至几秒钟前查看过的雇员档案信息(同样，我们在浏览WEB页面的时候也经常会使用“后退”按钮) 。这时我们通常会有两种程序实现方式:一种是把过去查看过的雇员信息保存在内存中，每一个存储了雇员档案信息的Java对象的生命周期贯穿整个应用程序始终;另一种是当用户开始查看其他雇员的档案信息的时候 ， 把存储了当前所查看的雇员档案信息的Java对象结束引用，使得垃圾收集线程可以回收其所占用的内存空间，当用户再次需要浏览该雇员的档案信息的时候，重新构建该雇员的信息 。很显然 ， 第一种实现方法将造成大量的内存浪费，而第二种实现的缺陷在于即使垃圾收集线程还没有进行垃圾收集，包含雇员档案信息的对象仍然完好地保存在内存中，应用程序也要重新构建一个对象 。我们知道，访问磁盘文件、访问网络资源、查询数据库等操作都是影响应用程序执行性能的重要因素，如果能重新获取那些尚未被回收的Java对象的引用 ， 必将减少不必要的访问，大大提高程序的运行速度 。
2 如果使用软引用
SoftReference的特点是它的一个实例保存对一个Java对象的软引用，该软引用的存在不妨碍垃圾收集线程对该Java对象的回收 。也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对这个Java对象回收前 ， SoftReference类所提供的get()方法返回Java对象的强引用 。另外，一旦垃圾线程回收该Java对象之后，get()方法将返回null 。
看下面代码:
MyObject aRef = new
MyObject();
SoftReference aSoftRef=new SoftReference(aRef);
此时，对于这个MyObject对象，有两个引用路径，一个是来自SoftReference对象的软引用，一个来自变量aReference的强引用，所以这个MyObject对象是强可及对象 。
随即，我们可以结束aReference对这个MyObject实例的强引用:
aRef = null;
此后，这个MyObject对象成为了软可及对象 。如果垃圾收集线程进行内存垃圾收集，并不会因为有一个SoftReference对该对象的引用而始终保留该对象 。Java虚拟机的垃圾收集线程对软可及对象和其他一般Java对象进行了区别对待:软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的 。也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软可及对象，而且虚拟机会尽可能优先回收长时间闲置不用的软可及对象，对那些刚刚构建的或刚刚使用过的“新”软可反对象会被虚拟机尽可能保留 。在回收这些对象之前，我们可以通过:
MyObject anotherRef=(MyObject)aSoftRef.get();
重新获得对该实例的强引用 。而回收之后，调用get()方法就只能得到null了 。
3 使用ReferenceQueue清除失去了软引用对象的SoftReference
作为一个Java对象，SoftReference对象除了具有保存软引用的特殊性之外 ， 也具有Java对象的一般性 。所以，当软可及对象被回收之后 ， 虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值，需要一个适当的清除机制 ， 避免大量SoftReference对象带来的内存泄漏 。在java.lang.ref包里还提供了ReferenceQueue 。如果在创建SoftReference对象的时候，使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法，如:
ReferenceQueue queue = new
ReferenceQueue();
SoftReference
ref=new
SoftReference(aMyObject, queue);
那么当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时，ref所强引用的SoftReference对象被列入ReferenceQueue 。也就是说 ， ReferenceQueue中保存的对象是Reference对象 ， 而且是已经失去了它所软引用的对象的Reference对象 。另外从ReferenceQueue这个名字也可以看出，它是一个队列，当我们调用它的poll()方法的时候，如果这个队列中不是空队列，那么将返回队列前面的那个Reference对象 。
在任何时候，我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收 。如果队列为空，将返回一个null,否则该方法返回队列中前面的一个Reference对象 。利用这个方法，我们可以检查哪个SoftReference所软引用的对象已经被回收 。于是我们可以把这些失去所软引用的对象的SoftReference对象清除掉 。常用的方式为:
SoftReference ref = null;
while ((ref = (EmployeeRef) q.poll()) != null) {
// 清除ref
}
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; i10; i) {
byte[] buff = new byte[1024 * 1024];
SoftReferencebyte[] sr = new SoftReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; ilist.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; i10; i) {
buff = new byte[1024 * 1024];
SoftReferencebyte[] sr = new SoftReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; ilist.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; i10; i) {
byte[] buff = new byte[1024 * 1024];
WeakReferencebyte[] sr = new WeakReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; ilist.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.
*
* @returncodenull/code
*/
public T get() {
return null;
}
public PhantomReference(T referent, ReferenceQueue? super T q) {
super(referent, q);
}
}
那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？
五，引用队列（ReferenceQueue）
引用队列可以与软引用、弱引用以及虚引用一起配合使用 ， 当垃圾回收器准备回收一个对象时，如果发现它还有引用 ， 那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去 。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施 。
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软引用代码 jvm软引用】关于java软引用代码和jvm软引用的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：如何启动服务器？ 怎么开启sever服务器

    下一篇：怎么看xp电脑显卡，怎么看xp电脑显卡型号