对象访问方式及四大引用

发表于 2021-03-13 更新于 2022-02-21

Java中对象的访问方式

概述

建立对象是为了使用对象，我们的Java程序需要通过栈上的reference数据来操作堆上的具体对象。由于reference类型在Java虚拟机规范中只规定了一个指向对象的引用，并没有定义这个引用应该通过何种方式去定位、访问堆中的对象的具体位置，所以对象访问方式也是取决于虚拟机实现的。目前主流的访问方式有使用句柄和直接指针两种

使用句柄的访问方式

如果使用句柄访问方式，Java堆中会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据和类型数据各自的具体地址信息。对象实例数据一般在堆中开辟，类型数据一般储存在方法区中。

使用直接指针的访问方式

直接指针访问方式指reference中直接储存对象在heap中的内存地址，但对应的类型数据访问地址需要在实例中存储

两种对象访问方式的区别

使用句柄来访问的最大好处就是reference中存储的是稳定的句柄地址，在对象被移动（垃圾收集时移动对象是非常普遍的行为）时只会改变句柄中的实例数据指针，而reference本身不需要修改。

使用直接指针访问方式的最大好处就是速度更快，它节省了一次指针定位的时间开销，由于对象的访问在Java中非常频繁，因此这类开销积少成多后也是一项非常可观的执行成本。但它的缺点是，当对象被移动时（如进行GC后的内存重新排列），对象的引用（reference）也需要同步更新

Java中的四大引用

概述

在很多时候，我们对于一个对象的存活时长要求是不一样的，这通常表现为我们希望的垃圾回收器对它的回收时机的不同。对于一些比较重要的对象，我们希望垃圾回收器永远不去回收它，即使此时内存空间已经不足了，因为一旦它被回收，将导致严重的后果。而对于一些不那么重要的对象，比如在做图片缓存的时候生成的大量图片的缓存对象，我们希望垃圾回收器只在内存不足的情况下去对它进行回收以提升用户体验

一般来说内存泄漏有两种情况。一种情况如在C/C++ 语言中的，在堆中的分配的内存，在没有将其释放掉的时候，就将所有能访问这块内存的方式都删掉（如指针重新赋值）；另一种情况则是在内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。第一种情况，在 Java 中已经由于垃圾回收机制的引入，得到了很好的解决。所以， Java 中的内存泄漏，主要指的是第二种情况。

而我们知道，在Java中垃圾回收器的运行是JVM操作的，但是我们仍然可以在一定程度上与垃圾回收器进行交互，其目的在于更好的帮助垃圾回收器管理好应用的内存。从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

强引用(Strong Reference)

强引用就是在程序代码普遍存在的例如Object object=new Object（）这类的引用；如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

软引用(Soft Reference)

软引用用来描述一些有用但非必需的对象。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

软引用对象是在jvm内存不够的时候才会被回收，我们调用System.gc()方法只是起通知作用，JVM什么时候扫描回收对象是JVM自己的状态决定的。**就算扫描到软引用对象也不一定会回收它，只有内存不够的时候才会回收**。

弱引用（Weak Reference）

弱引用也用来描述非必需的对象。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期，被弱引用关联的对象只能生存到下一次垃圾收集发生前。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

虚引用（Phantom Reference）

“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会影响与之关联的对象的生存时间，也无法通过虚引用来取得一个对象的实例。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。

当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收，即在这个对象被回收时可以得到通知。

举个例子

String str = new String(  " hello " );
     ReferenceQueue< String > referenceQueue = new ReferenceQueue < String > ();
     //SoftReference< String > reference = new SoftReference < String > (str, referenceQueue);
     /*
     无论是否调用System.gc()，输出为
     hello
     null
     一个对象只具有软引用，内存不足时才回收
     */
     WeakReference< String > reference = new WeakReference < String > (str, 		referenceQueue);
     /*
     没有进行垃圾回收时，输出为
     hello
     null
     进行垃圾回收后，输出为
     null
     java.lang.ref.WeakReference@1b6d3586
     一个对象只具有弱引用，在垃圾回收器线程扫描它所管辖的内存区域的过程中，
     一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
     */
     //PhantomReference<String> reference = new PhantomReference<String>(str,referenceQueue);
     /*
     没有被垃圾回收时，输出为
     null
     null
     被垃圾回收后，输出为
     null
     java.lang.ref.PhantomReference@1b6d3586
     一个对象仅持有虚引用，那么它就和没有任何引用一样，
     在任何时候都可能被垃圾回收*/

     str = null ;  // 取消"hello"对象的强引用
     System.gc();
     String str1 = reference.get();
     System.out.println(str1);
     System.out.println(referenceQueue.poll());

如图，“hello”对象同时具有强引用和弱引用

当str为null，“hello”对象不再具有强引用，而只具有弱引用

引用的区别与选择

屏幕截图(149).png

SoftReference 具有构建 Cache 系统的特质，因此我们可以结合哈希表实现一个简单的缓存系统。这样既能保证能够尽可能多的缓存信息，又可以保证 Java虚拟机不会因为内存泄露而抛出 OutOfMemoryError 。这种缓存机制特别适合于内存对象生命周期长，且生成内存对象的耗时比较长的情况，例如缓存列表封面图片等。对于一些生命周期较长，但是生成内存对象开销不大的情况，使用WeakReference 能够达到更好的内存管理的效果。
如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建；如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出。这时候就可以使用软引用

Handler 可能引起的内存泄漏

我们经常会写这样的代码。

private final Handler mHandler = new Handler(){
       @Override
       public void handleMessage(Message msg) {
           super.handleMessage(msg);
       }
   };

当你这样写的时候，你一定会收到编译器的黄色警告。

In Android, Handler classes should be static or leaks might occur, Messages enqueued on the application thread’s MessageQueue also retain their target Handler. If the Handler is an inner class, its outer class will be retained as well. To avoid leaking the outer class, declare the Handler as a static nested class with a WeakReference to its outer class

在 Java 中，非静态的内部类和匿名内部类都会 隐式地 持有其外部类的引用。由于Handler是非静态内部类所以其持有当前Activity的隐式引用，如果Handler没有被释放，其所持有的外部引用也就是Activity也不可能被释放，当一个对象已经不需要再使用了，本来该被回收时，而有另外一个正在使用的对象持有它的引用从而导致它不能被回收，这导致本该被回收的对象不能被回收而停留在堆内存中，这就产生了内存泄漏

要解决这样的问题，我们在继承 Handler 的时候，要么是放在单独的类文件中，要么直接使用静态内部类，静态的内部类不会持有外部类的引用。当需要在静态内部类中调用外部的 Activity 的时候，我们可以直接采用弱引用进行处理，所以我们大概修改后的代码如下。

 private static final class MyHandler extends Handler{
        private final WeakReference<MainActivity> mWeakReference;
        
        public MyHandler(MainActivity activity){
            mWeakReference = new WeakReference<>(activity);
        }
        
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            MainActivity activity = mWeakReference.get();
            if (activity != null){
                // 开始写业务代码
            }
        }
    }
    
private MyHandler mMyHandler = new MyHandler(this);

其实在我们实际开发中，不止一个地方可能会用到内部类，我们都需要在这样的情况下尽量使用静态内部类加弱引用的方式解决我们可能出现的内存泄漏问题。