Java四种引用解析以及在Android的应用

JVM垃圾回收(GC)机制

我们知道，Java垃圾回收(GC)机制是JVM的重要组成部分，也是JVM平常工作的重点，事实上，JVM的后台线程每时每刻都在监控整个应用程序的状态，并在必要的时候启动GC，回收内存一些没有被引用的内存，那么是如何找到这些需要回收的内存呢,我们先来看一段代码:

public class GCDemo {
    private Object instance = null;
    private static final int _1MB = 1024 * 1024;

    private byte[] bytes = new byte[_1MB];

    public static void main(String[] args) {
        GCDemo gcDemo = new GCDemo();
        GCDemo gcDemo1 = new GCDemo();
        gcDemo.instance=gcDemo1;
        gcDemo1.instance=gcDemo;

        gcDemo=null;
        gcDemo1=null;
        System.gc();
    }
}

下面看一下内存回收的打印:，记得运行选项加上-XX:+PrintGCDetails选项

[GC (System.gc()) [PSYoungGen: 4669K->696K(37888K)] 4669K->704K(123904K), 0.0049445 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
[Full GC (System.gc()) [PSYoungGen: 696K->0K(37888K)] [ParOldGen: 8K->603K(86016K)] 704K->603K(123904K), [Metaspace: 3008K->3008K(1056768K)], 0.0078845 secs] [Times: user=0.06 sys=0.00, real=0.01 secs]
Heap
 PSYoungGen      total 37888K, used 983K [0x00000000d6000000, 0x00000000d8a00000, 0x0000000100000000)
 这里省略了一些非必要信息

可以看到从4669->696的结果来看，这种相互引用的内存，最后还是被回收了. 这种回收算法叫做引用计数法，就是给对象中添加一个引用计数器，每当一个地方引用这个对象时，计数器值+1；当引用失效时，计数器值-1。任何时刻计数值为0的对象就是不可能再被使用的。这种算法使用场景很多，但是这种算法很难解决对象之间相互引用的情况,就比如上面的例子的运行结果显示，所以Java并没有用这种回收算法，那么Java是使用什么算法来找到按下需要被回收的内存的呢？答案是可达性分析算法。

可达性分析法

这个算法的基本思想是通过一系列称为“GC Roots”的对象作为起始点，从这些节点向下搜索，搜索所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链（即GC Roots到对象不可达）时，则证明此对象是不可用的。在Java语言中可以作为GC Roots的对象包括：

● 虚拟机栈中引用的对象

● 方法区中静态属性引用的对象

● 方法区中常量引用的对象

● 本地方法栈中JNI（即Native方法）引用的对象

可达性分析算法如图所示:

左边的都是可达的，而右边Object4,Object5,Object6虽然有引用，但是因为到GC Roots是不可达的，因此Java也是会回收掉这部分的内存的。

Java中四种引用状态分析

在JDK1.2之前，Java中引用的定义很传统：如果引用类型的数据中存储的数值代表的是另一块内存的起始地址，就称这块内存代表着一个引用。这种定义没有错误，但是过于笼统，实际上只是简单的说明了一个对象只有被引用或者没被引用两种状态。而我们希望描述这样一类对象：当内存空间还足够时，则能保留在内存中；如果内存空间在进行垃圾收集后还是非常紧张，则可以抛弃这些对象。很多系统的缓存功能都符合这样的应用场景。因此在JDK1.2之后，Java对引用的概念进行了扩充，将引用分为强引用、软引用、弱引用、虚引用4种，这4种引用强度依次减弱,下面将分析每种引用在内存回收时候的表现以及涉及到的在Android中的具体应用。

在写代码之前，先配置一下参数: -Xms20M -Xmx20M -Xmn10M -XX:SurvivorRatio=8 -verbose:gc -XX:+PrintGCDetails

这说明:

● 堆大小固定为20M(最小和最大都为20M,所以就固定为20M了)

● 新生代大小为10M，SurvivorRatio设置为8，则Eden区大小=8M，每个Survivor区大小=1M，每次有9M的新生代内存空间可用来new对象

● 当发生GC的时候打印GC的简单信息，当程序运行结束打印GC详情

●. 强引用

代码中普遍存在的类似"Object obj = new Object()"这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象,哪怕是JVM抛出OutOfMemoryError异常，也不会回收内存的，下面看一段代码即可明白

public class GCDemo {

    private static final int _1MB = 1024 * 1024;
    private byte[] bytes = new byte[_1MB];

    public static void main(String[] args) {
        test();
    }

    private static void test() {
        byte[] bytes1 = new byte[5 * _1MB];
        byte[] bytes2 = new byte[5 * _1MB];
        System.gc();
    }
}
结果如下:
  [Full GC (System.gc()) [Tenured: 5120K->5120K(10240K), 0.0018258 secs] 10993K->10843K(19456K), [Metaspace: 3090K->3090K(1056768K)], 0.0018492 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
Heap
 par new generation   total 9216K, used 6023K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  73% used [0x00000000fec00000, 0x00000000ff1e1db0, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
  to   space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
 tenured generation   total 10240K, used 5120K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
   the space 10240K,  50% used [0x00000000ff600000, 0x00000000ffb00010, 0x00000000ffb00200, 0x0000000100000000)
 Metaspace       used 3110K, capacity 4494K, committed 4864K, reserved 1056768K
  class space    used 340K, capacity 386K, committed 512K, reserved 1048576K

我们可以看到，即使GC了也没有回收，而且共有10993K内存转移到了老年代了，从10993K->10843K可以判断出并没有回收掉，也就是说 10M的字节没有被回收 ,那么我们加大一点测试看看会不会内存错误，

public class GCDemo {

    private static final int _1MB = 1024 * 1024;
    private byte[] bytes = new byte[_1MB];

    public static void main(String[] args) {
        test();
    }

    private static void test() {
        byte[] bytes1 = new byte[5 * _1MB];
        byte[] bytes2 = new byte[10* _1MB];
        System.gc();
    }
}
可以看到发生错误了，
[Full GC (Allocation Failure) [TenuredException in thread "main" java.lang.OutOfMemoryError: Java heap space
	at Collections.GCDemo.test(GCDemo.java:17)
	at Collections.GCDemo.main(GCDemo.java:12)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
Java HotSpot(TM) 64-Bit Server VM warning: Using the ParNew young collector with the Serial old collector is deprecated and will likely be removed in a future release
: 5725K->5700K(10240K), 0.0018018 secs] 5725K->5700K(19456K), [Metaspace: 3042K->3042K(1056768K)], 0.0018229 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
Heap
 par new generation   total 9216K, used 322K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)

那要怎样释放呢，手动置为null，就失去了GC Roots引用连，这样就可以回收了

public class GCDemo {

    private static final int _1MB = 1024 * 1024;
    private byte[] bytes = new byte[_1MB];

    public static void main(String[] args) {
        test();
        //System.gc
    }

    private static void test() {
        byte[] bytes1 = new byte[5 * _1MB];
        byte[] bytes2 = new byte[5 * _1MB];
        bytes1 = null;
        bytes2 = null;
        System.gc();
    }
}
[Full GC (System.gc()) [TenuredJava HotSpot(TM) 64-Bit Server VM warning: Using the ParNew young collector with the Serial old collector is deprecated and will likely be removed in a future release
: 5120K->602K(10240K), 0.0018229 secs] 11015K->602K(19456K), [Metaspace: 3069K->3069K(1056768K)], 0.0018489 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]
Heap
 par new generation   total 9216K, used 299K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)

可以看到从11015K->602K,说明手动置null之后经过了一个gc，那些都被回收了,实际上如果不手动置为null，也可以在方法执行之后再调用System.gc()方法的，这样一样可以回收内存，其原因是test()只是一个方法，当JVM执行完方法返回的时候，会清空当前的栈帧，而测试的是在方法内分配的，自然就会随着方法结束而释放掉内存了，就是注释去掉，然后不用手动置null，是一样的效果来的。

软引用

软引用是用来描述一些还有用但并非必需的对象，对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK1.2之后，提供了SoftReference类来实现软引用,下面看代码，由于区别只是跟上面的方法的代码区别，因此这里只写出方法的代码了:

private static void test() {
        byte[] bytes1 = new byte[5 * _1MB];
        SoftReference<byte[]> softReference = new SoftReference<byte[]>(bytes1);
        System.out.println("GC前：" + softReference.get());
        bytes1 = null;
        System.gc();
        System.out.println("GC后：" + softReference.get());
    }

结果如下:

GC前：[[email protected]1540e19d
[Full GC (System.gc()) [Tenured: 0K->5725K(10240K), 0.0038452 secs] 6598K->5725K(19456K), [Metaspace: 3042K->3042K(1056768K)], 0.0038802 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]
GC后：[[email protected]1540e19d
Heap
 par new generation   total 9216K, used 322K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)

可以看到 6598K->5725K,并没有回收掉，因为当前的内存还是足够的，而且从获取来看，也不为null,现在加大测试，看代码:

private static void test() {
        SoftReference<byte[]> softReference = new SoftReference<byte[]>(new byte[4*_1MB]);
        SoftReference<byte[]> softReference1 = new SoftReference<byte[]>(new byte[4*_1MB]);
        SoftReference<byte[]> softReference2 = new SoftReference<byte[]>(new byte[4*_1MB]);
        SoftReference<byte[]> softReference3 = new SoftReference<byte[]>(new byte[4*_1MB]);
        SoftReference<byte[]> softReference4 = new SoftReference<byte[]>(new byte[4*_1MB]);
        SoftReference<byte[]> softReference5 = new SoftReference<byte[]>(new byte[4*_1MB]);

        System.out.println("GC后：" + softReference.get());
        System.out.println("GC1后：" + softReference1.get());
        System.out.println("GC2后：" + softReference2.get());
        System.out.println("GC3后：" + softReference3.get());
        System.out.println("GC4后：" + softReference4.get());
        System.out.println("GC5后：" + softReference5.get());
    }

下面是运行结果:

: 4195K->23K(9216K), 0.0021830 secs] 8870K->8793K(19456K), 0.0021967 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
GC后：null
GC1后：null
GC2后：null
GC3后：[[email protected]1540e19d
GC4后：[[email protected]677327b6
GC5后：[[email protected]14ae5a5
Heap
 par new generation   total 9216K, used 4454K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)

大家可以看到，前面三个被回收了，而后面三个就正常打印了，这就证明了 软引用在内存不足的时候会释放掉引用，进而被回收 , 所以，很多时候对一些非必需的对象，我们可以将直接将其与软引用关联，这样内存不够时会先回收软引用关联的对象而不会抛出OutOfMemoryError，毕竟抛出OutOfMemoryError意味着整个应用将停止运行,这个软引用在Android中发挥了重要的作用，特别是在缓存方面，由于一些需求，需要加快显示妥或者数据之类，需要用到内存上的缓存，但是要求在系统内存紧张的时候就回收掉，因此这个场景下就非常适合用软引用做缓存了，下面举个android中的图片加载的例子，在还没有ImageLoader,Glide,Fresco的时候，图片加载需要自己封装，内存缓存也可以用这种的，下面看一下简单的代码分析:

public class ImageLoader {

    private static volatile ImageLoader sInstance;
    private Handler mHandler = new Handler(Looper.getMainLooper());

    private ImageLoader() {
        mCache.clear();
    }

    public static ImageLoader getInstance() {
        if (sInstance == null) {
            synchronized (ImageLoader.class) {
                if (sInstance == null) {
                    sInstance = new ImageLoader();
                }
            }
        }
        return sInstance;
    }

    private Map<String, SoftReference<Drawable>> mCache = new HashMap<>();

    /**
     * 加载图片
     */
    public void loadDrawable(final String path, ImageLoaderCallback callback) {
        //有缓存
        if (mCache.containsKey(path)) {
            SoftReference<Drawable> softReference = mCache.get(path);
            if (softReference != null) {
                Log.d("[app]", "从缓存获取");
                Drawable drawable = softReference.get();
                if (drawable != null) {
                    callback.imageLoad(drawable);
                } else {
                    loadImageFromUrl(path, callback);
                }
            }
        }
        //没有缓存,将从网络获取加载
        else {
            loadImageFromUrl(path, callback);
        }
    }

    private void loadImageFromUrl(String imagePath, ImageLoaderCallback callback) {
        UserThread userThread = new UserThread(imagePath, callback);
        userThread.start();
    }

    private Drawable loadImageFromUrl(String path) {
        try {
            return Drawable.createFromStream(new URL(path).openStream(), "imageLoader");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    //定义一个回调接口
    public interface ImageLoaderCallback {
        void imageLoad(Drawable drawable);
    }

    class UserThread extends Thread {
        private String imagePath;
        private ImageLoaderCallback callback;

        public UserThread(String imagePath, ImageLoaderCallback callback) {
            this.imagePath = imagePath;
            this.callback = callback;
        }

        @Override
        public void run() {
            super.run();
            final Drawable drawable = loadImageFromUrl(imagePath);
            if (drawable != null) {
                Log.d("[app]", "从网络获取图片并且加入缓存");
                mCache.put(imagePath, new SoftReference<Drawable>(drawable));
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (callback != null) {
                            callback.imageLoad(drawable);
                        }
                    }
                });
            }
        }
    }
}

当然，这是随便写的测试的代码，实际上需要考虑很多问题，在代码中，我们用一个Map<String,SortReference>来做内存的缓存，可以看到在加载的时候首先判断是否有缓存，如果没有的话，就从网络加载并且存储起来，下次如果是有就直接加载图片了，下面是测试代码:

ImageLoader.getInstance().loadDrawable("http://news.21-sun.com/UserFiles/x_Image/x_20150606083511_0.jpg",
                new ImageLoader.ImageLoaderCallback() {
                    @Override
                    public void imageLoad(Drawable drawable) {
                        Log.d("[app]", "drawable=" + drawable);
                    }
                });
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                ImageLoader.getInstance().loadDrawable("http://news.21-sun.com/UserFiles/x_Image/x_20150606083511_0.jpg",
                        new ImageLoader.ImageLoaderCallback() {
                            @Override
                            public void imageLoad(Drawable drawable) {
                                Log.d("[app]", "drawable=" + drawable);
                            }
                        });
            }
        },3000);
    结果为:
12-18 14:32:11.743 19735-19788/com.example.hotfixdemo D/[app]: 从网络获取图片并且加入缓存
12-18 14:32:11.743 19735-19735/com.example.hotfixdemo D/[app]: drawable=android.graphics.drawable.BitmapDrawable@aef5e9
12-18 14:32:14.457 19735-19735/com.example.hotfixdemo D/[app]: 从缓存获取
12-18 14:32:14.457 19735-19735/com.example.hotfixdemo D/[app]: drawable=android.graphics.drawable.BitmapDrawable@aef5e9

可以看到，在第一次加载的时候没有缓存便从网络获取，然后会加入到缓存里面，第二次加载的时候就直接从缓存获取，这样就加快了图片的显示了，当然了，除了图片的图片缓存，列表的内存缓存或者其他数据的内存缓存都是可以利用软引用的，大家可以在实际项目中用用就知道了。

弱引用

弱引用也是用来描述非必需对象的，但是它的强度比软引用更弱一些，跟软引用内存不足被回收不同的是，被弱引用关联的对象，只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK1.2之后，提供了WeakReference类来实现弱引用,下面我们来测试一下:

private static void test() {
        WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[8 * _1MB]);
        System.out.println("弱引用GC前：" + weakReference.get());
        System.gc();
        System.out.println("弱引用GC后：" + weakReference.get());
    }
    测试结果如下:
    弱引用GC前：[[email protected]1540e19d
[Full GC (System.gc()) [Tenured: 8192K->608K(10240K), 0.0019216 secs] 9670K->608K(19456K), [Metaspace: 3095K->3095K(1056768K)], 0.0019498 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
弱引用GC后：null
Heap
 par new generation   total 9216K, used 410K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)

从8192K->608K以及弱引用之后的结果来看，弱引用的对象在gc之后确实被回收了，而不是在内存不足的时候才会被回收，弱引用在Andsroid中也很多地方用到，由于在gc之后就会被断掉引用链，因此，在防止内存泄露方面可以发挥作用，比如Handler在Activity里面，如果没有定义为静态类，则持有外部类Activity的实例，在页面销毁的时候，如果还没有释放掉引用，就容易导致内存泄露。因此可以用静态的Handler来弱引用Activity即可断掉引用链，下面是代码:

private static class UserHandler extends Handler{
        private WeakReference<MainActivity>  weakReference;
        public UserHandler(MainActivity mainActivity){
            weakReference=new WeakReference<>(mainActivity);
        }
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (weakReference!=null){
                MainActivity mainActivity=weakReference.get();
                if (mainActivity!=null){
                    //具体业务逻辑...
                }
            }
        }
    }

类似这样的就可以有效防止持有外部Activity而造成内存泄露了，除了Handler，图片的持有也是可以利用弱引用的，总之，要理解在垃圾收集器工作的时候，被弱引用的对象都会被回收，这个特点，然后根据实际业务就可以适当利用了。

虚引用

虚引用,它是最弱的一中引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。在JDK1.2之后，提供给了PhantomReference类来实现虚引用,由于没办法通过虚引用来获取一个对象实例,为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知，一般情况下在实际的项目中不会用到，大家了解一下就好。

时间： 2024-10-13 10:49:31

Java四种引用解析以及在Android的应用的相关文章

java四种引用及在LeakCanery中应用

java 四种引用 Java4种引用的级别由高到低依次为: StrongReference > SoftReference > WeakReference > PhantomReference 1. StrongReference String tag = new String("T"); 此处的 tag 引用就称之为强引用.而强引用有以下特征: 1. 强引用可以直接访问目标对象. 2. 强引用所指向的对象在任何时候都不会被系统回收. 3. 强引用可能导致内存泄漏.

Java四种引用包括强引用，软引用，弱引用，虚引用

Java四种引用包括强引用,软引用,弱引用,虚引用. 强引用: 只要引用存在,垃圾回收器永远不会回收Object obj = new Object();//可直接通过obj取得对应的对象 如obj.equels(new Object());而这样 obj对象对后面new Object的一个强引用,只有当obj这个引用被释放之后,对象才会被释放掉,这也是我们经常所用到的编码形式. 软引用: 非必须引用,内存溢出之前进行回收,可以通过以下代码实现Object obj = new Object();S

【转】JAVA四种引用（强引用，弱引用，软引用，虚引用）

转自:http://www.cnblogs.com/gudi/p/6403953.html 1.强引用(StrongReference) 强引用是使用最普遍的引用.如果一个对象具有强引用,那垃圾回收器绝不会回收它.如下: Object o=new Object(); // 强引用 当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题.如果不使用时,要通过如下方式来弱化引用,如下: o=null; // 帮

Java四种引用 强引用,软引用,弱引用,虚引用(转)

强引用 : 只要引用存在,垃圾回收器永远不会回收 Object obj= new Object(); Object 对象对后面 new Object的一个强引用, 只有当obj这个被释放之后,对象才会被释放掉, 这也是我们经常所用到的编码形式. 软引用: 非必须引用,内存溢出之前进行回收,可以通过以下代码实现 Object obj = new Object(); SoftReference<Object> sf = new SoftReference<Object>(obj);ob

Java虚拟机15：再谈四种引用状态

JVM的四种引用状态 在Java虚拟机5:Java垃圾回收(GC)机制详解一文中,有简单提到过JVM的四种引用状态,当时只是简单学习,知道有这么一个概念,对四种引用状态理解不深.这两天重看虚拟机这部分的时候,写了很多例子详细研究了一下JVM的几种引用,对于JVM的引用理解加深了不少,因此总结写一篇文章总结并分享下. 首先,还是先从JVM四种引用状态开始,这部分摘抄自周志明老师的<深入理解Java虚拟机:JVM高级特性与最佳实践>一书. 在JDK1.2之前,Java中的引用的定义很传统:如果re

Java 中的四种引用

1.强引用(Strong Reference)在 Java 中四种引用中是"最强"的,我们平时通过 new 关键字创建的对象都属于强引用,如下面的代码: Person person = new Person();其中的 person 就是一个强引用,只有当它不再被使用后才会被垃圾回收器回收掉.当内存不足时,但是其依然在被使用中,那么垃圾回收器也不会回收其引用的对象:JVM 宁愿报"内存泄漏错误 (OutofMemoryError)",终止程序也不会回收此引用所关联的

java中存在的四种引用

Java开发中存在四种引用,它们分别是: 强引用(StrongReference) 强引用是使用最普遍的引用.如果一个对象具有强引用, 那垃圾回收器绝不会回收它.当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题. 软引用(SoftReference)如果一个对象只具有软引用,则内存空间足够, 垃圾回收器就不会回收它:如果内存空间不足了,就会回收这些对象的内存. 只要垃圾回收器没有回收它,该对象就可以被

JAVA中的四种引用以及ReferenceQueue和WeakHashMap的使用示例

简介: 本文主要介绍JAVA中的四种引用: StrongReference(强引用).SoftReferenc(软引用).WeakReferenc(弱引用).PhantomReference(虚引用)的作用.同时我们还将介绍ReferenceQueue和WeakHashMap的功能和使用示例. 欢迎探讨,如有错误敬请指正 如需转载,请注明出处 http://www.cnblogs.com/nullzx/ 1. JAVA中的四种引用 四种引用中,软引用.若引用.虚引用都需要相关类来创建.创建的时候

Java 中的四种引用及垃圾回收策略

Java 中有四种引用:强引用.软引用.弱引用.虚引用: 其主要区别在于垃圾回收时是否进行回收: 1.强引用 使用最普遍的引用.如果一个对象具有强引用,那就 类似于必不可少的生活用品,垃圾回收器绝不会回收它.当内存空 间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足问题. 2.软引用(SoftReference) 如果一个对象只具有软引用,那就类似于可有可物的生活用品.如果内存空间足够,垃圾回收器就不会回收它,如果