在java中提供4个级别的引用:强引用、软引用、弱引用和虚引用。除了强引用外,其他3中引用均可以在java.lang.ref包中找到对应的类。开发人员可以在应用程序中直接使用他们。

1 强引用

强引用就是程序中一般使用的引用类型,强引用的对象是可触及的,不会被回收。相对的,软引用、弱引用和虚引用的对象是软可触及的、弱可触及的和虚可触及的,在一定条件下,都是可以被回收的。

强引用示例:StringBuffer str = new StringBuffer("Hello world");

假设以上代码是在函数体内运行的,那么局部变量str将被分配在栈上,而对象StringBuffer实例被分配在堆上。局部变量str指向StringBuffer实例所在堆空间,通过str可以操作该实例,那么str就是StringBuffer实例的强引用。

此时,如果再运行一个赋值语句:

StringBuffer str1 = str;

则str所指向的对象也将被str1所指向,同时在局部变量表上会分配空间存放str1变量。此时该StringBuffer实例就有两个引用。对引用的“==”操作用于表示两操作数所指向的堆空间地址是否相同,不表示两操作数所指的对象是否相同。

强引用的特点:

  • 强引用可以直接访问目标对象
  • 强引用所指向的对象在任何时候都不会被系统回收,虚拟机宁愿抛出OOM异常,也不会回收强引用所指的对象。
  • 强引用可能导致内存泄漏

2 软引用----可被回收的引用

软引用是比强引用弱一点的引用类型,一个对象只持有软引用,那么当堆空间不足时,就会被回收。软引用使用java.lang.ref.SoftReference类型

package com.jvm;
import java.lang.ref.SoftReference;
public class SoftRef {
  public static class User{
    public User(int id,String name){
      this.id = id;
      this.name = name;
    }
    public int id;
    public String name;
    @Override
    public String toString() {
      return "[id="+String.valueOf(id)+",name="+name+"]";
    }
  }
  public static void main(String[] args) {
    User u = new User(1,"gim");
    SoftReference<User> userSoftRef = new SoftReference<User>(u);//创建引用给定对象的新的软引用
    u = null; //去除强引用

    System.out.println(userSoftRef.get());
    System.gc();
    System.out.println("After GC:");
    System.out.println(userSoftRef.get());

    byte[] b = new byte[1024*925*7];//分配7M左右,使内存空间紧张
    System.gc();
    System.out.println(userSoftRef.get());
  }
}

如果虚拟机不加参数设置堆内存限制,则打印出:

[id=1,name=gim]
After GC:
[id=1,name=gim]
[id=1,name=gim]

因为虚拟机的内存总量是九十多兆,且虚拟机企图使用的最大内存总量是这个的十几倍。故不会出现资源紧张,也不会产生内存溢出现象。

如果使用-Xmx10m运行上述代码,可以得到:

[id=1,name=gim](第一次从软引用中获取数据)
After GC:
[id=1,name=gim](GC没有清除软引用)
null(由于内存紧张,软引用被清除)

结论:GC未必会回收软引用的对象,但是当内存资源紧张时,软引用对象会被回收,所以软引用对象不会引起内存溢出。

3 弱引用-----发现即回收

弱引用是一种比软引用较弱的引用类型。在系统GC时,只要发现弱引用,不管系统堆空间使用情况如何,都会将对象进行回收。但是由于垃圾回收器的优先级通常很低,因此,并不一定能很快的发现持有弱引用的对象。在这种情况下,弱引用对象可以存在较长的时间,一旦一个弱引用对象被垃圾回收器回收,便会加入一个注册的引用队列(这一点和软引用很像)。弱引用使用java.lang.ref.WeakReference类实现。

实例2:展示弱引用的特点

package com.jvm;
import java.lang.ref.WeakReference;
public class WeakRef {
  public static class User{
    public User(int id,String name){
      this.id = id;
      this.name = name;
    }
    public int id;
    public String name;

    @Override
    public String toString() {
      return "[id="+String.valueOf(id)+",name="+name+"]";
    }
  }

  public static void main(String[] args) {
    User u = new User(1,"gim");
    WeakReference<User> userReference = new WeakReference<User>(u);
    u = null;
    System.out.println(userReference.get());
    System.gc();
    System.out.println("After GC:");
    System.out.println(userReference.get());
  }
}

不用设置虚拟机参数,直接运行代码打印出:

[id=1,name=gim]
After GC:
null

可以看书,GC之后,弱引用对象立即被清除。弱引用和软引用一样,在构造弱引用时,也可以指定一个引用队列,当弱引用对象被回收时,就会加入指定的引用队列,通过这个队列可以跟踪对象的回收情况。

注意:软引用、弱引用都非常适合来保存那些可有可无的缓存数据(应用场景)。如果这么做,当系统内存不足时,这些缓存数据会被回收,不会导致内存的溢出,而当内存资源充足时,这些缓存又可以存在相当长的时间,从而起到加速系统的作用。

4 虚引用----对象回收跟踪

一个持有虚引用的对象,和没有引用几乎一样。随时都可能被垃圾回收器回收,当试图通过虚引用的get()方法取得强引用时,总是会失败。

并且,虚引用必须和引用队列一起使用,它的作用主要是跟踪垃圾回收过程

当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象后,将这个虚引用加入引用队列,以通知引用程序对象的回收情况。

实例3 :使用虚引用跟踪一个可复活对象的回收

package com.jvm;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class TraceCanReliveObj {
  public static TraceCanReliveObj obj;  //可以复活对象
  static ReferenceQueue<TraceCanReliveObj> phantomQueue = null;
  public static class CheckRefQueue extends Thread{
    @Override
    public void run() {
      while(true){
        if(phantomQueue!=null){
          PhantomReference<TraceCanReliveObj> objt = null;
          try{
            objt = (PhantomReference<TraceCanReliveObj>) phantomQueue.remove();
          }catch(InterruptedException e){
            e.printStackTrace();
          }
          if(objt!=null){
            System.out.println("TraceCanReliveObj is delete by GC");
          }
        }
      }
    }
  }

  @Override
  protected void finalize() throws Throwable {
    super.finalize();
    System.out.println("CanReliveObj finalize called");
    obj = this; //使得对象复活
  }
  @Override
  public String toString() {
    return "I am CanReliveObj";
  }
  public static void main(String[] args) throws InterruptedException {
    Thread t = new CheckRefQueue();
    t.setDaemon(true);//守护线程
    t.start();
    phantomQueue = new ReferenceQueue<TraceCanReliveObj>();
    obj = new TraceCanReliveObj();

    //构造了TraceCanReliveObj对象的虚引用,并指定了引用队列。
    PhantomReference<TraceCanReliveObj> phantomRef = new PhantomReference<TraceCanReliveObj>(obj, phantomQueue);
    obj = null;  //将强引用去除
    System.gc();  //第一次进行GC,由于对象可复活,GC无法回收该对象。
    Thread.sleep(1000);
    if(obj==null){
      System.out.println("obj 是 null");
    }else{
      System.out.println("obj 可用");
    }
    System.out.println("第二次GC");
    obj = null;
    System.gc(); //第二次进行GC,由于finalize()只会被调用一次,因此第2次GC会回收对象,同时其引用队列应该也会捕获到对象的回收
    Thread.sleep(1000);
    if(obj==null){
      System.out.println("obj 是 null");
    }else{
      System.out.println("obj 可用");
    }
  }
}

直接运行代码打印:

CanReliveObj finalize called    (对象复活)
obj 可用
第二次GC           (第2次,对象无法复活) 
TraceCanReliveObj is delete by GC (引用队列捕获到对象被回收)
obj 是 null

由于虚引用可以跟踪对象的回收时间,因此,也可以将一些资源释放操作放置在虚引用中执行和记录。

Java的四种引用之强弱软虚的更多相关文章

  1. Java的四种引用,强弱软虚,用到的场景

    众所周知,java中是JVM负责内存的分配和回收,这是它的优点(使用方便,程序不用再像使用c那样操心内存),但同时也是它的缺点(不够灵活).为了解决内存操作不灵活这个问题,可以采用软引用等方法. 在J ...

  2. java的四种引用,强弱软虚和jvm优化

    1.强引用(StrongReference)强引用是使用最普遍的引用.如果一个对象具有强引用,那垃圾回收器绝不会回收它.如下: Object o=new Object();   //  强引用 当内存 ...

  3. java的四种引用,强弱软虚

    1.利用软引用和弱引用解决OOM问题:用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系,在内存不足时,JVM会自动回收这些缓存图片对象所占用的空间,从而有效地避免了OOM的 ...

  4. Java中四种引用:强、软、弱、虚引用

    这篇文章非常棒:http://alinazh.blog.51cto.com/5459270/1276173 Java中四种引用:强.软.弱.虚引用 1.1.强引用当我们使用new 这个关键字创建对象时 ...

  5. Java基础:Java的四种引用

    在Java基础:java虚拟机(JVM)中,我们提到了Java的四种引用.包括:强引用,软引用,弱引用,虚引用.这篇博客将详细的讲解一下这四种引用. 1. 强引用 2. 软引用 3. 弱引用 4. 虚 ...

  6. Java的四种引用方式

    一.引用基本概念 从JDK1.2版本开始,把对象的引用分为四种级别,从而使程序能更加灵活的控制对象的生命周期.这四种级别由高到低依次为:强引用.软引用.弱引用.虚引用. 1.强引用(StrongRef ...

  7. Java虚拟机(五)Java的四种引用级别

    1.前言 HotSpot采取了可达性分析算法用来判断对象是否被能被GC,无论是引用计算法还是可达性分析算法都是判断对象是否存在引用来判断对象是否存活.如果reference类型的数据中存储的数值代表的 ...

  8. java gc --- 四种引用

    古龙有<七种武器>,java里有四种引用. 下文主要是对 <understanding-weak-references>这一博文的重点进行翻译 强引用,strong refer ...

  9. [转载] Java的四种引用关系

    目录 1 强引用 (Final Reference) 2 软引用 (Soft Reference) 2.1 案例1: 软引用的垃圾回收 2.2 案例2: 软引用缓存的使用 2.3 软引用的应用场景 3 ...

随机推荐

  1. Enduring Exodus CodeForces - 655C (二分)

    链接 大意: n个房间, 1为占用, 0为未占用, John要将k头奶牛和自己分进k+1个空房间, 求John距最远的奶牛距离的最小值 这种简单题卡了20min.... 显然对于固定的k+1个房间, ...

  2. cf188C(最大子段和&&思维)

    C. Functions again time limit per test 1 second memory limit per test 256 megabytes input standard i ...

  3. spring cloud学习(七)Spring Cloud Config(续)

    Spring Cloud Config(续) 个人参考项目 个人博客 : https://zggdczfr.cn/ 个人参考项目 : (整合到上一个案例中)https://github.com/Fun ...

  4. HDU 2492 树状数组

    DES:按照位置编号给你选手的rank值.每场比赛要有一个裁判,位置和rank在两个选手之间.两场比赛裁判不同 或有一个选手不同则可以说 两场比赛不同.问你一共可以有多少场比赛. 思路是遍历每个人当裁 ...

  5. C# 接收form表单中多个相同name值的问题

    以前接收form表单的值直接用FormCollection或自定义类来接收,当有多个相同Name的值时会自动用“,”隔开,这样就有了一个问题,当值中本身就含有“,”时就比较难处理了. 所以解决方法就是 ...

  6. POJ 3295 Tautology 构造 难度:1

    Tautology Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 9580   Accepted: 3640 Descrip ...

  7. Delphi IDE 版本

    产品 compiler Version version bds 2007-WIN32 VER 180 185 11 5.0 2009 VER 200 13 6.0 XE VER 220 15 8.0 ...

  8. Flask初级(十)flash与前台交互post详解

    Project name :Flask_Plan templates:templates static:static POST提交方式,首先要有表单 老实去改模板文件吧. 查询窗口我准备放在页面最顶上 ...

  9. cmake 手册详解

    cmake 手册中文版,后续再相关博客的其他链接中,感谢翻译的好人! https://www.cnblogs.com/coderfenghc/archive/2012/06/16/CMake_ch_0 ...

  10. request应用实例

    <%@ page language="java" import="java.util.*" pageEncoding="utf-8"% ...