2024年安卓最新Android中的引用类型及其使用分析_android四大引用，2024年最新android 面试问题

本文链接：https://blog.csdn.net/2401_84123201/article/details/138513378

结尾

腾讯T4级别Android架构技术脑图；查漏补缺，体系化深入学习提升

一线互联网Android面试题含详解（初级到高级专题）

这些题目是今年群友去腾讯、百度、小米、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。并且大多数都整理了答案，熟悉这些知识点会大大增加通过前两轮技术面试的几率

有Android开发3-5年基础，希望突破瓶颈，成为架构师的小伙伴，可以关注我

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

Android中有四种引用类型，分别是：

Strong reference - 强引用
Soft Reference - 软引用
Weak Reference -弱引用
Phantom Reference - 虚引用

不同的引用类型有着不同的特性，同时也对应着不同的使用场景。

1.Strong reference - 强引用

实际编码中最常见的一种引用类型。常见形式如：A a = new A();等。强引用本身存储在栈内存中，其存储指向对内存中对象的地址。一般情况下，当对内存中的对象不再有任何强引用指向它时，垃圾回收机器开始考虑可能要对此内存进行的垃圾回收。如当进行编码：a = null，此时，刚刚在堆中分配地址并新建的a对象没有其他的任何引用，当系统进行垃圾回收时，堆内存将被垃圾回收。

SoftReference、WeakReference、PhantomReference都是类java.lang.ref.Reference的子类。Reference作为抽象基类，定义了其子类对象的基本操作。Reference子类都具有如下特点：
1.Reference子类不能无参化直接创建，必须至少以强引用对象为构造参数，创建各自的子类对象；
2.因为1中以强引用对象为构造参数创建对象，因此，使得原本强引用所指向的堆内存中的对象将不再只与强引用本身直接关联，与Reference的子类对象的引用也有一定联系。且此种联系将可能影响到对象的垃圾回收。

根据不同的子类对象对其指示对象（强引用所指向的堆内存中的对象）的垃圾回收不同的影响特点，分别形成了三个子类，即SoftReference、WeakReference和PhantomReference。

2.Soft Reference - 软引用

软引用的一般使用形式如下：
A a = new A();
SoftReference srA = new SoftReference(a);

通过对象的强引用为参数，创建了一个SoftReference对象，并使栈内存中的wrA指向此对象。

此时，进行如下编码：a = null，对于原本a所指向的A对象的垃圾回收有什么影响呢？

先直接看一下下面一段程序的输出结果：

 1 import java.lang.ref.SoftReference;
 2 
 3 public class ReferenceTest {
 4 
 5     public static void main(String[] args) {
 6 
 7         A a = new A();
 8         
 9         SoftReference<A> srA = new SoftReference<A>(a);
10 
11         a = null;
12 
13         if (srA.get() == null) {
14             System.out.println("a对象进入垃圾回收流程");
15         } else {
16             System.out.println("a对象尚未被回收" + srA.get());
17         }
18 
19         // 垃圾回收
20         System.gc();
21 
22         if (srA.get() == null) {
23             System.out.println("a对象进入垃圾回收流程");
24         } else {
25             System.out.println("a对象尚未被回收" + srA.get());
26         }
27 
28     }
29 }
30 
31 class A {
32 
33 }

##输出结果为：

1 a对象尚未被回收A@4807ccf6
2 a对象尚未被回收A@4807ccf6

当 a = null后，堆内存中的A对象将不再有任何的强引用指向它，但此时尚存在srA引用的对象指向A对象。当第一次调用srA.get()方法返回此指示对象时，由于垃圾回收器很有可能尚未进行垃圾回收，此时get()是有结果的，这个很好理解。当程序执行System.gc();强制垃圾回收后，通过srA.get()，发现依然可以得到所指示的A对象，说明A对象并未被垃圾回收。那么，软引用所指示的对象什么时候才开始被垃圾回收呢？需要满足如下两个条件：
1.当其指示的对象没有任何强引用对象指向它；
2.当虚拟机内存不足时。

因此，SoftReference变相的延长了其指示对象占据堆内存的时间，直到虚拟机内存不足时垃圾回收器才回收此堆内存空间。

3.Weak Reference - 弱引用

同样的，软引用的一般使用形式如下：
A a = new A();
WeakReference wrA = new WeakReference(a);

当没有任何强引用指向此对象时，其垃圾回收又具有什么特性呢？

 1 import java.lang.ref.WeakReference;
 2 
 3 public class ReferenceTest {
 4 
 5     public static void main(String[] args) {
 6 
 7         A a = new A();
 8 
 9         WeakReference<A> wrA = new WeakReference<A>(a);
10 
11         a = null;
12 
13         if (wrA.get() == null) {
14             System.out.println("a对象进入垃圾回收流程");
15         } else {
16             System.out.println("a对象尚未被回收" + wrA.get());
17         }
18 
19         // 垃圾回收
20         System.gc();
21 
22         if (wrA.get() == null) {
23             System.out.println("a对象进入垃圾回收流程");
24         } else {
25             System.out.println("a对象尚未被回收" + wrA.get());
26         }
27 
28     }
29 
30 }
31 
32 class A {
33 
34 }

##输出结果为：

a对象尚未被回收A@52e5376a
a对象进入垃圾回收流程

输出的第一条结果解释同上。当进行垃圾回收后，wrA.get()将返回null，表明其指示对象进入到了垃圾回收过程中。因此，对弱引用特点总结为：

WeakReference不改变原有强引用对象的垃圾回收时机，一旦其指示对象没有任何强引用对象时，此对象即进入正常的垃圾回收流程。

那么，依据此特点，很可能有疑问：WeakReference存在又有什么意义呢？

其主要使用场景见于：当前已有强引用指向强引用对象，此时由于业务需要，需要增加对此对象的引用，同时又不希望改变此引用的垃圾回收时机，此时WeakReference正好符合需求，常见于一些与生命周期的场景中。

下面给出一个Android中关于WeakReference使用的场景 —— 结合静态内部类和WeakReference来解决Activity中可能存在的Handler内存泄露问题。

Activity中我们需要新建一个线程获取数据，使用handler - sendMessage方式。下面是这一过程的一般性代码：

1 public class MainActivity extends Activity {
 2 
 3     //...
 4     private int page;
 5     private Handler handler = new Handler() {
 6 
 7         @Override
 8         public void handleMessage(Message msg) {
 9             if (msg.what == 1) {
10 
11                 //...
12 
13                 page++;
14             } else {
15 
16                 //...
17 
18             }
19 
20         };
21     };
22 
23     @Override
24     protected void onCreate(Bundle savedInstanceState) {
25         super.onCreate(savedInstanceState);
26         setContentView(R.layout.activity_main);
27 
28         //...
29 
30         new Thread(new Runnable() {
31             @Override
32             public void run() {
33                 //.. 
34                 Message msg = Message.obtain();
35                 msg.what = 1;
36                 //msg.obj = xx;
37                 handler.sendMessage(msg);
38             }
39         }).start();
40 
41         //...
42 
43     }
44 
45 }

在Eclispe中Run Link，将会看到警示信息：This Handler class should be static or leaks might occur …点击查看此信息，其详情中对问题进行了说明并给出了建议性的解决方案。

Issue: Ensures that Handler classes do not hold on to a reference to an outer class
Id: HandlerLeak

Since this Handler is declared as an inner class, it may prevent the outer class from being garbage collected. If the Handler is using a Looper or MessageQueue for a thread other than the main thread, then there is no issue. If the Handler is using the Looper or MessageQueue of the main thread, you need to fix your Handler declaration, as follows: Declare the Handler as a static class;In the outer class, instantiate a WeakReference to the outer class and pass this object to your Handler when you instantiate the Handler; Make all references to members of the outer class using the WeakReference object.

大致的意思是建议将Handler定义成内部静态类，并在此静态内部类中定义一个WeakReference的引用，由于指示外部的Activity对象。

问题分析：

Activity具有自身的生命周期，Activity中新开启的线程运行过程中，可能此时用户按下了Back键，或系统内存不足等希望回收此Activity，由于Activity中新起的线程并不会遵循Activity本身的什么周期，也就是说，当Activity执行了onDestroy,由于线程以及Handler 的HandleMessage的存在，使得系统本希望进行此Activity内存回收不能实现，因为非静态内部类中隐性的持有对外部类的引用，导致可能存在的内存泄露问题。

因此，在Activity中使用Handler时，一方面需要将其定义为静态内部类形式，这样可以使其与外部类（Activity）解耦，不再持有外部类的引用，同时由于Handler中的handlerMessage一般都会多少需要访问或修改Activity的属性，此时，需要在Handler内部定义指向此Activity的WeakReference，使其不会影响到Activity的内存回收同时，可以在正常情况下访问到Activity的属性。

Google官方给出的建议写法为：

 1 public class MainActivity extends Activity {
 2 
 3     //...
 4     private int page;
 5     private MyHandler mMyHandler = new MyHandler(this);
 6 
 7     private static class MyHandler extends Handler {
 8 
 9         private WeakReference<MainActivity> wrActivity;
10 
11         public MyHandler(MainActivity activity) {
12             this.wrActivity = new WeakReference<MainActivity>(activity);
13         }
14 
15         @Override
16         public void handleMessage(Message msg) {
17             if (wrActivity.get() == null) {
18                 return;
19             }
20             MainActivity mActivity = wrActivity.get();
21             if (msg.what == 1) {
22 
23                 //...
24                 mActivity.page++;
25 
26             } else {
27 
28                 //...
29 
30             }
31         }
32 
33     }
34 
35     @Override
36     protected void onCreate(Bundle savedInstanceState) {
37         super.onCreate(savedInstanceState);
38         setContentView(R.layout.activity_main);
39 
40         //...
41 
42         new Thread(new Runnable() {
43             @Override
44             public void run() {
45                 //.. 
46                 Message msg = Message.obtain();
47                 msg.what = 1;
48                 //msg.obj = xx;
49                 mMyHandler.sendMessage(msg);
50             }
51         }).start();
52 
53         //...
54 
55     }
56 
57 }

对于SoftReference和WeakReference，还有一个构造器参数为ReferenceQueue，当SoftReference或WeakReference所指示的对象确实被垃圾回收后，其引用将被放置于ReferenceQueue中。注意上文中，当SoftReference或WeakReference的get()方法返回null时，仅是表明其指示的对象已经进入垃圾回收流程，此时对象不一定已经被垃圾回收。而只有确认被垃圾回收后，如果ReferenceQueue，其引用才会被放置于ReferenceQueue中。

看下面的一个例子：

 1 public class ReferenceTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         A a = new A();
 6 
 7         WeakReference<A> wrA = new WeakReference<A>(a);
 8 
 9         a = null;
10 
11         if (wrA.get() == null) {
12             System.out.println("a对象进入垃圾回收流程");
13         } else {
14             System.out.println("a对象尚未被回收" + wrA.get());
15         }
16 
17         // 垃圾回收
18         System.gc();
19 
20         if (wrA.get() == null) {
21             System.out.println("a对象进入垃圾回收流程");
22         } else {
23             System.out.println("a对象尚未被回收" + wrA.get());


## 总结

学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！

**最后如何才能让我们在面试中对答如流呢？**

答案当然是平时在工作或者学习中多提升自身实力的啦，那如何才能正确的学习，有方向的学习呢？有没有免费资料可以借鉴？为此我整理了一份Android学习资料路线：

![](https://img-blog.csdnimg.cn/img_convert/6a7df0b32eb65309dfce175a41664445.webp?x-oss-process=image/format,png)

这里是一部分我工作以来以及参与过的大大小小的面试收集总结出来的一套**BAT大厂面试资料专题包**，主要还是希望大家在如今大环境不好的情况下面试能够顺利一点，希望可以帮助到大家。

![](https://img-blog.csdnimg.cn/img_convert/f277e1ebb9fc67dcf4296f00d8446907.webp?x-oss-process=image/format,png)

好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者**刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划**。来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。

最后，祝愿即将跳槽和已经开始求职的大家都能找到一份好的工作！

> 这些只是整理出来的部分面试题，后续会持续更新，希望通过这些高级面试题能够降低面试Android岗位的门槛，让更多的Android工程师理解Android系统，掌握Android系统。喜欢的话麻烦点击一个喜欢再关注一下~



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618156601)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

自己的之后的面试计划及职业规划。

最后，祝愿即将跳槽和已经开始求职的大家都能找到一份好的工作！

> 这些只是整理出来的部分面试题，后续会持续更新，希望通过这些高级面试题能够降低面试Android岗位的门槛，让更多的Android工程师理解Android系统，掌握Android系统。喜欢的话麻烦点击一个喜欢再关注一下~



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618156601)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**