http://www.jcodecraeer.com/plus/view.php?aid=9560
目录介绍
- 0.关于四种引用
- 0.1 引用说明
- 0.2 关于Java下ref包和Android下ref包
- 1.强引用
- 1.0 关于强引用引用的场景
- 1.1 强引用介绍
- 1.2 强引用的特点
- 1.3 注意相互引用情况
- 2.软引用
- 2.0 关于SoftReference软引用
- 2.1 软引用应用场景
- 2.2 软引用的简单使用
- 2.3 软引用的特点
- 2.4 实际应用案例
- 2.5 注意避免软引用获取对象为null
- 3.弱引用
- 3.0 关于WeakReference弱引用
- 3.1 WeakReference:防止内存泄漏,要保证内存被虚拟机回收
- 3.1.1 先看一个handler小案例
- 3.1.2 为什么这样会造成内存泄漏
- 3.1.3 根本原因
- 3.2 弱引用解决办法
- 3.3 弱引用实际应用案例
- 4.虚引用
- 4.0 关于PhantomReference类虚引用
- 4.1 Android实际开发中没有用到过
- 5.四种引用其他介绍
- 5.1 弱引用和软引用区别
- 5.2 使用软引用或者弱引用防止内存泄漏
- 5.3 到底什么时候使用软引用,什么时候使用弱引用呢?
- 5.4 四种引用用一张表总结[摘自网络]
- 6.源码分析
- 6.1 首先看看如何通过弱引用加载图片
- 6.2 看看Reference的源代码
- 6.3 看看ReferenceQueue的enqueue函数
- 6.4 看看ReferenceQueue的enqueueLocked(Reference)函数
- 6.5 接着看看ReferenceQueue.isEnqueued()代码
- 6.6 那么enqueueLocked(Reference)函数中的Cleaner是做什么的
- 6.7 软引用SoftReference源码
- 6.8 弱引用WeakReference源码
- 6.9 虚引用PhantomReference源码
- 7.关于其他
- 7.1 关于参考案例
- 7.2 关于版本说明
- 7.3 关于我的博客
特此说明
- 博客汇总链接:https://www.jianshu.com/p/53017c3fc75d
- 视频案例:https://github.com/yangchong211/YCVideoPlayer
- 音频案例:https://github.com/yangchong211/YCAudioPlayer
- recyclerView复杂封装库:https://github.com/yangchong211/YCRefreshView
- 状态栏工具类:https://github.com/yangchong211/YCStatusBar
- 状态切换管理器库:https://github.com/yangchong211/YCStateLayout
0.关于四种引用
0.1 引用说明
- java.lang.ref包中提供了几个类:SoftReference类、WeakReference类和PhantomReference类,它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列,它可以和这三种引用类联合使用,以便跟踪Java虚拟机回收所引用的对象的活动。
0.2 关于Java下ref包和Android下ref包
- 在Android下的ref包结构
- 在java下的ref包
1.强引用
1.0 关于强引用引用的场景
- 直接new出来的对象
- String str = new String(“yc”);
1.1 强引用介绍
- 强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。
- 通过引用,可以对堆中的对象进行操作。在某个函数中,当创建了一个对象,该对象被分配在堆中,通过这个对象的引用才能对这个对象进行操作。
1.2 强引用的特点
- 强引用可以直接访问目标对象。
- 强引用所指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常,也不会回收强引用所指向的对象。
- 强引用可能导致内存泄露。
1.3 注意相互引用情况
2.软引用
2.0 关于SoftReference软引用
- SoftReference:软引用–>当虚拟机内存不足时,将会回收它指向的对象;需要获取对象时,可以调用get方法。
- 可以通过java.lang.ref.SoftReference使用软引用。一个持有软引用的对象,不会被JVM很快回收,JVM会根据当前堆的使用情况来判断何时回收。当堆的使用率临近阈值时,才会回收软引用的对象。
2.1 软引用应用场景
- 例如从网络上获取图片,然后将获取的图片显示的同时,通过软引用缓存起来。当下次再去网络上获取图片时,首先会检查要获取的图片缓存中是否存在,若存在,直接取出来,不需要再去网络上获取。
2.2 软引用的简单使用
- 用法如下
MyObject aRef = new MyObject();
SoftReference aSoftRef = new SoftReference(aRef);
MyObject anotherRef = (MyObject)aSoftRef.get();
2.3 软引用的特点
- 2.3.1 特点:
- 如果一个对象只具有软引用,那么如果内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
-
2.3.2 代码如下
ReferenceQueue queue = new ReferenceQueue();
SoftReference ref = new SoftReference(aMyObject, queue);
- 2.3.3 如何回收:
- 那么当这个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
}
2.4 实际应用案例
- 2.4.1 正常是用来处理图片这种占用内存大的情况
-
代码如下所示
View view = findViewById(R.id.button);
Bitmap bitmap = BitmapFactory.decodeResource(getResources(),R.drawable.ic_launcher);
Drawable drawable = new BitmapDrawable(bitmap);
SoftReference<Drawable> drawableSoftReference = new SoftReference<Drawable>(drawable);
if(drawableSoftReference != null) {
view.setBackground(drawableSoftReference.get());
}
- 2.4.2 这样使用软引用好处
- 通过软引用的get()方法,取得drawable对象实例的强引用,发现对象被未回收。在GC在内存充足的情况下,不会回收软引用对象。此时view的背景显示
- 实际情况中,我们会获取很多图片.然后可能给很多个view展示, 这种情况下很容易内存吃紧导致oom,内存吃紧,系统开始会GC。这次GC后,drawables.get()不再返回Drawable对象,而是返回null,这时屏幕上背景图不显示,说明在系统内存紧张的情况下,软引用被回收。
- 使用软引用以后,在OutOfMemory异常发生之前,这些缓存的图片资源的内存空间可以被释放掉的,从而避免内存达到上限,避免Crash发生。
2.5 注意避免软引用获取对象为null
- 在垃圾回收器对这个Java对象回收前,SoftReference类所提供的get方法会返回Java对象的强引用,一旦垃圾线程回收该Java对象之后,get方法将返回null。所以在获取软引用对象的代码中,一定要判断是否为null,以免出现NullPointerException异常导致应用崩溃。
3.弱引用
3.0 关于WeakReference弱引用
- 3.0.1 WeakReference
- 弱引用–>随时可能会被垃圾回收器回收,不一定要等到虚拟机内存不足时才强制回收。要获取对象时,同样可以调用get方法。
- 3.0.2 特点
- 如果一个对象只具有弱引用,那么在垃圾回收器线程扫描的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。
- 弱引用也可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
3.1 WeakReference:防止内存泄漏,要保证内存被虚拟机回收
-
3.1.1 先看一个handler小案例【千万不要忽视淡黄色警告】
- 3.1.2 为什么这样会造成内存泄漏
-
这种情况就是由于android的特殊机制造成的:当一个android主线程被创建的时候,同时会有一个Looper对象被创建,而这个Looper对象会实现一个MessageQueue(消息队列),当我们创建一个handler对象时,而handler的作用就是放入和取出消息从这个消息队列中,每当我们通过handler将一个msg放入消息队列时,这个msg就会持有一个handler对象的引用。因此当Activity被结束后,这个msg在被取出来之前,这msg会继续存活,但是这个msg持有handler的引用,而handler在Activity中创建,会持有Activity的引用,因而当Activity结束后,Activity对象并不能够被gc回收,因而出现内存泄漏。
- 3.1.3 根本原因
- Activity在被结束之后,MessageQueue并不会随之被结束,如果这个消息队列中存在msg,则导致持有handler的引用,但是又由于Activity被结束了,msg无法被处理,从而导致永久持有handler对象,handler永久持有Activity对象,于是发生内存泄漏。但是为什么为static类型就会解决这个问题呢?因为在java中所有非静态的对象都会持有当前类的强引用,而静态对象则只会持有当前类的弱引用。声明为静态后,handler将会持有一个Activity的弱引用,而弱引用会很容易被gc回收,这样就能解决Activity结束后,gc却无法回收的情况。
3.2 弱引用解决办法
-
代码如下所示
private MyHandler handler = new MyHandler(this);
private static class MyHandler extends Handler{
WeakReference<FirstActivity> weakReference;
MyHandler(FirstActivity activity) {
weakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
}
}
}
3.3 弱引用实际应用案例
- 具体案例可以参考我的代码:https://github.com/yangchong211/YCVideoPlayer
4.虚引用
4.0 关于PhantomReference类虚引用
- 虚引用是所有引用类型中最弱的一个。一个持有虚引用的对象,和没有引用几乎是一样的,随时都可能被垃圾回收器回收。当试图通过虚引用的get()方法取得强引用时,总是会失败。并且,虚引用必须和引用队列一起使用,它的作用在于跟踪垃圾回收过程。 当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在垃圾回收后,销毁这个对象,奖这个虚引用加入引用队列。
4.1 Android实际开发中没有用到过
- 貌似开发中没有接触过虚引用
5.四种引用其他介绍
5.1 弱引用和软引用区别
- 弱引用与软引用的根本区别在于:只具有弱引用的对象拥有更短暂的生命周期,可能随时被回收。而只具有软引用的对象只有当内存不够的时候才被回收,在内存足够的时候,通常不被回收。
5.2 使用软引用或者弱引用防止内存泄漏
- 在Android应用的开发中,为了防止内存溢出,在处理一些占用内存大而且声明周期较长的对象时候,可以尽量应用软引用和弱引用技术。
- 软引用,弱引用都非常适合来保存那些可有可无的缓存数据。如果这样做,当系统内存不足时,这些缓存数据会被回收,不会导致内存溢出。而当内存资源充足时,这些缓存数据又可以存在相当长的时间。
5.3 到底什么时候使用软引用,什么时候使用弱引用呢?
- 个人认为,如果只是想避免OutOfMemory异常的发生,则可以使用软引用。如果对于应用的性能更在意,想尽快回收一些占用内存比较大的对象,则可以使用弱引用。
- 还有就是可以根据对象是否经常使用来判断。如果该对象可能会经常使用的,就尽量用软引用。如果该对象不被使用的可能性更大些,就可以用弱引用。
- 另外,和弱引用功能类似的是WeakHashMap。WeakHashMap对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的回收,回收以后,其条目从映射中有效地移除。WeakHashMap使用ReferenceQueue实现的这种机制。
5.4 四种引用用一张表总结[摘自网络]
6.源码分析
6.1 首先看看如何通过弱引用加载图片
6.2 看看Reference的源代码
- 6.2.1 源码说明:
- 看到Reference除了带有对象引用referent的构造函数,还有一个带有ReferenceQueue参数的构造函数。那么这个ReferenceQueue用来做什么呢?
- 需要我们从enqueue这个函数来开始分析。当系统要回收Reference持有的对象引用referent的时候,Reference的enqueue函数会被调用,而在这个函数中调用了ReferenceQueue的enqueue函数。
-
那么我们来看看ReferenceQueue的enqueue函数做了什么?
-
6.2.2 看看这段源代码
public abstract class Reference<T> {
private static boolean disableIntrinsic = false;
private static boolean slowPathEnabled = false;
volatile T referent; /* Treated specially by GC */
final ReferenceQueue<? super T> queue;
Reference queueNext;
Reference<?> pendingNext;
//返回此引用对象的引用。如果这个引用对象有由程序或垃圾收集器清除,然后此方法返回
public T get() {
return getReferent();
}
private final native T getReferent();
//清除此引用对象。调用此方法不会将对象加入队列
public void clear() {
this.referent = null;
}
//是否引用对象已进入队列,由程序或垃圾收集器。
//如果该引用对象在创建队列时没有注册,则该方法将始终返回
public boolean isEnqueued() {
return queue != null && queue.isEnqueued(this);
}
//添加引用对象到其注册的队列,如果他的方法是通过java代码调用
public boolean enqueue() {
return queue != null && queue.enqueue(this);
}
Reference(T referent) {
this(referent, null);
}
Reference(T referent, ReferenceQueue<? super T> queue) {
this.referent = referent;
this.queue = queue;
}
}
6.3 看看ReferenceQueue的enqueue函数
- 6.3.1 源码说明
- 可以看到首先获取同步锁,然后调用了enqueueLocked(Reference)函数
- 6.3.2 看看这段代码
6.4 看看ReferenceQueue的enqueueLocked(Reference)函数
- 6.4.1 源码说明
- 通过 enqueueLocked函数可以看到ReferenceQueue维护了一个队列(链表结构),而enqueue这一系列函数就是将reference添加到这个队列(链表)中
- 6.4.2 看看这段代码
6.5 接着看看ReferenceQueue.isEnqueued()代码
- 6.5.1 让我们回到Reference源码中
-
可以看到除了enqueue这个函数还有一个isEnqueued函数,同样这个函数调用了ReferenceQueue的同名函数,源码如下:
boolean isEnqueued(Reference<? extends T> reference) {
synchronized (lock) {
return reference.queueNext != null && reference.queueNext != sQueueNextUnenqueued;
}
}
- 6.5.2 源码分析说明
- 可以看到先获取同步锁,然后判断该reference是否在队列(链表)中。由于enqueue和isEnqueue函数都要申请同步锁,所以这是线程安全的。
- 这里要注意“reference.queueNext != sQueueNextUnenqueued”用于判断该Reference是否是一个Cleaner类,在上面ReferenceQueue的enqueueLocked函数中我们可以看到如果一个Reference是一个Cleaner,则调用它的clean方法,同时并不加入链表,并且将其queueNext设置为sQueueNextUnequeued,这是一个空的虚引用
6.6 那么enqueueLocked(Reference)函数中的Cleaner是做什么的
- 在stackoverflow网站中找到这个解释
- sun.misc.Cleaner是JDK内部提供的用来释放非堆内存资源的API。JVM只会帮我们自动释放堆内存资源,但是它提供了回调机制,通过这个类能方便的释放系统的其他资源。
- 可以看到Cleaner是用于释放非堆内存的,所以做特殊处理。
- 通过enqueue和isEnqueue两个函数的分析,ReferenceQueue队列维护了那些被回收对象referent的Reference的引用,这样通过isEnqueue就可以判断对象referent是否已经被回收,用于一些情况的处理。
6.7 软引用SoftReference源码
- 6.7.1 关于这段源码分析
- 可以看到SoftReference有一个类变量clock和一个变量timestamp,这两个参数对于SoftReference至关重要。
- clock:记录了上一次GC的时间。这个变量由GC(garbage collector)来改变。
- timestamp:记录对象被访问(get函数)时最近一次GC的时间。
- 那么这两个参数有什么用?
- 我们知道软引用是当内存不足时可以回收的。但是这只是大致情况,实际上软应用的回收有一个条件:
- clock - timestamp <= free_heap * ms_per_mb
- free_heap是JVM Heap的空闲大小,单位是MB
- ms_per_mb单位是毫秒,是每MB空闲允许保留软引用的时间。Sun JVM可以通过参数-XX:SoftRefLRUPolicyMSPerMB进行设置
-
举个栗子:
- 目前有3MB的空闲,ms_per_mb为1000,这时如果clock和timestamp分别为5000和2000,那么
- 5000 - 2000 <= 3 * 1000
- 条件成立,则该次GC不对该软引用进行回收。
- 所以每次GC时,通过上面的条件去判断软应用是否可以回收并进行回收,即我们通常说的内存不足时被回收。
- 6.7.2 源码如下所示
public class SoftReference<T> extends Reference<T> {
static private long clock;
private long timestamp;
public SoftReference(T referent) {
super(referent);
this.timestamp = clock;
}
public SoftReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
this.timestamp = clock;
}
public T get() {
T o = super.get();
if (o != null && this.timestamp != clock)
this.timestamp = clock;
return o;
}
}
6.8 弱引用WeakReference源码
- 6.8.1 源码分析说明
- 没有其他代码,GC时被回收掉。
- 6.8.2 源码如下所示
public class WeakReference<T> extends Reference<T> {
public WeakReference(T referent) {
super(referent);
}
public WeakReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
6.9 虚引用PhantomReference源码
- 6.9.1 源码分析说明
- 可以看到get函数返回null,正如前面说得虚引用无法获取对象引用。(注意网上有些文章说虚引用不持有对象的引用,这是有误的,通过构造函数可以看到虚引用是持有对象引用的,但是无法获取该引用
- 同时可以看到虚引用只有一个构造函数,所以必须传入ReferenceQueue对象。
- 前面提到虚引用的作用是判断对象是否被回收,这个功能正是通过ReferenceQueue实现的。
-
这里注意:不仅仅是虚引用可以判断回收,弱引用和软引用同样实现了带有ReferenceQueue的构造函数,如果创建时传入了一个ReferenceQueue对象,同样也可以判断。
- 6.9.2 源码如下所示
public class PhantomReference<T> extends Reference<T> {
public T get() {
return null;
}
public PhantomReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
7.关于其他
7.1 关于参考案例
- http://blog.csdn.net/qq_20280683/article/details/77897876
- http://blog.csdn.net/to_be_designer/article/details/72673421
7.2 关于版本说明
- v1.0 16年6月18日
- v1.1 17年11月18日,简单的分析了源码
- v1.2 18年重新整理了笔记
7.3 关于我的博客
- 我的个人站点:www.yczbj.org,www.ycbjie.cn
- github:https://github.com/yangchong211
- 知乎:https://www.zhihu.com/people/yang-chong-69-24/pins/posts
- 简书:http://www.jianshu.com/u/b7b2c6ed9284
- csdn:http://my.csdn.net/m0_37700275
- 喜马拉雅听书:http://www.ximalaya.com/zhubo/71989305/
- 泡在网上的日子:http://www.jcodecraeer.com/member/content_list.php?channelid=1
- 邮箱:yangchong211@163.com
- 阿里云博客:https://yq.aliyun.com/users/article?spm=5176.100- 239.headeruserinfo.3.dT4bcV