一篇文章搞定《RecyclerView缓存复用机制》

前言

本篇文章，暂时不加入预加载进行讲解。先了解缓存机制再加入预加载会很快的进行理解。如果混淆在一起会觉得很乱。

零、为什么要缓存

RecyclerView是Android 5.0提出的新的UI控件，顾名思义，它会回收其列表项视图以供重用。
具体而言，当一个列表项被移出屏幕后，RecyclerView并不会销毁其视图，而是会缓存起来，以提供给新进入屏幕的列表项重用，这种重用可以：

• 避免重复创建不必要的视图
• 避免重复执行昂贵的findViewById
  从而达到的改善性能、提升应用响应能力、降低功耗的效果。而要了解其中的工作原理，我们还得回到RecyclerView是如何构建动态列表的这一步。

一、RecyclerView如何构建我们的列表视图

与RecyclerView构建动态列表相关联的几个重要类中，Adapter与ViewHolder负责配合使用，共同定义RecyclerView列表项数据的展示方式，其中：

• ViewHolder是一个「包含列表项视图(itemView)的封装容器」，同时也是「RecyclerView缓存复用的主要对象」。
• Adapter则提供了「数据<->视图」 的“绑定”关系，其包含以下几个关键方法：
  • onCreateViewHolder：负责创建并初始化ViewHolder及其关联的视图，但不会填充视图内容。
  • onBindViewHolder：负责提取适当的数据，填充ViewHolder的视图内容。
    然而，这2个方法并非每一个进入屏幕的列表项都会回调，相反，由于视图创建及findViewById执行等动作都主要集中在这2个方法，每次都要回调的话反而效率不佳。因此，我们应该通过对ViewHolder对象积极地缓存复用，来尽量减少对这2个方法的回调频次。

1. 最优情况是——取得的缓存对象正好是原先的ViewHolder对象，这种情况下既不需要重新创建该对象，也不需要重新绑定数据，即拿即用。
2. 次优情况是——取得的缓存对象虽然不是原先的ViewHolder对象，但由于二者的列表项类型(itemType)相同，其关联的视图可以复用，因此只需要重新绑定数据即可。
3. 最后实在没办法了，才需要执行这2个方法的回调，即创建新的ViewHolder对象并绑定数据。 实际上，这也是RecyclerView从缓存中查找最佳匹配ViewHolder对象时所遵循的优先级顺序。而真正负责执行这项查找工作的，则是RecyclerView类中一个被称为「回收者」的内部类——Recycler。

二、缓存过程

那我们就从头去看到底是怎么去查找到我们的视图的（因为更直观去看所以先不加预加载的逻辑了）
还记得我们在创建我们的RecyclerView时设置了我们的layoutManager吗。其实我们的列表所有View的添加、构建都是我们设置的LayoutManager去启动的。这里只针对LinearLayoutManager这种布局管理器做一个讲解。

当然我们的RecyclerView支持LinearLayoutManager普通、GridLayoutManager网格、StaggeredGridLayoutManager瀑布流、FlexboxLayoutManager流式的、自定义的LayoutManager。
但是最后都会去使用我们的Recycle中的返回机制，也就是重要的方法：tryGetViewHolderForPositionByDeadline

这个方法会尝试通过从Recycler scrap、cache、RecycledViewPool查找或直接创建的形式来获取指定位置的ViewHolder。

public final class Recycler {
    
    
        ...
        /**
         * Attempts to get the ViewHolder for the given position, either from the Recycler scrap,
         * cache, the RecycledViewPool, or creating it directly.
         * 
         * 尝试通过从Recycler scrap缓存、RecycledViewPool查找或直接创建的形式来获取指定位置的ViewHolder。
         * ...
         */
        @Nullable
        ViewHolder tryGetViewHolderForPositionByDeadline(int position,
                boolean dryRun, long deadlineNs) {
    
    
            if (mState.isPreLayout()) {
    
    
                // 0 尝试从mChangedScrap中获取ViewHolder对象
                holder = getChangedScrapViewForPosition(position);
                ...
            }
            if (holder == null) {
    
    
                // 1.1 尝试根据position从mAttachedScrap或mCachedViews中获取ViewHolder对象
                holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
                ...
            }
            if (holder == null) {
    
    
                ...
                final int type = mAdapter.getItemViewType(offsetPosition);
                if (mAdapter.hasStableIds()) {
    
    
                    // 1.2 尝试根据id从mAttachedScrap或mCachedViews中获取ViewHolder对象
                    holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
                            type, dryRun);
                    ...
                }
                if (holder == null && mViewCacheExtension != null) {
    
    
                    // 2 尝试从mViewCacheExtension中获取ViewHolder对象
                    final View view = mViewCacheExtension
                            .getViewForPositionAndType(this, position, type);
                    if (view != null) {
    
    
                        holder = getChildViewHolder(view);
                        ...
                    }
                }
                if (holder == null) {
    
     // fallback to pool
                    // 3 尝试从mRecycledViewPool中获取ViewHolder对象
                    holder = getRecycledViewPool().getRecycledView(type);
                    ...
                }
                if (holder == null) {
    
    
                    // 4.1 回调createViewHolder方法创建ViewHolder对象及其关联的视图
                    holder = mAdapter.createViewHolder(RecyclerView.this, type);
                    ...
                }
            }
    
            if (mState.isPreLayout() && holder.isBound()) {
    
    
                ...
            } else if (!holder.isBound() || holder.needsUpdate() || holder.isInvalid()) {
    
    
                ...
                // 4.1 回调bindViewHolder方法提取数据填充ViewHolder的视图内容
                bound = tryBindViewHolderByDeadline(holder, offsetPosition, position, deadlineNs);
            }
    
            ...
    
            return holder;
        }
        ...
    }    

结合RecyclerView类中的源码及注释可知，Recycler会依次从mChangedScrap/mAttachedScrap、mCachedViews、mViewCacheExtension、mRecyclerPool中尝试获取指定位置或ID的ViewHolder对象以供重用，如果全都获取不到则直接重新创建。这其中涉及的几层缓存结构分别是：

三、缓存结构

1、mChangedScrap/mAttachedScrap

mChangedScrap/mAttachedScrap主要用于「临时存放仍在当前屏幕可见、但被标记为「移除」或「重用」的列表项」，其均以ArrayList的形式持有着每个列表项的ViewHolder对象，大小无明确限制，但一般来讲，其最大数就是屏幕内总的可见列表项数。

final ArrayList<ViewHolder> mAttachedScrap = new ArrayList<>();
ArrayList<ViewHolder> mChangedScrap = null;

但问题来了，既然是当前屏幕可见的列表项，为什么还需要缓存呢？又是什么时候列表项会被标记为「移除」或「重用」的呢？
这2个缓存结构实际上更多是为了避免出现像「局部刷新」这一类的操作，导致所有的列表项都需要重绘的情形。
区别在于，mChangedScrap主要的使用场景是：

1. 开启了列表项动画(itemAnimator)，并且列表项动画的canReuseUpdatedViewHolder(ViewHolder viewHolder)方法返回false的前提下；
2. 调用了notifyItemChanged、notifyItemRangeChanged这一类方法，通知列表项数据发生变化；

boolean canReuseUpdatedViewHolder(ViewHolder viewHolder) {
    
    
        return mItemAnimator == null || mItemAnimator.canReuseUpdatedViewHolder(viewHolder,
                viewHolder.getUnmodifiedPayloads());
    }
    
    public boolean canReuseUpdatedViewHolder(@NonNull ViewHolder viewHolder,
            @NonNull List<Object> payloads) {
    
    
        return canReuseUpdatedViewHolder(viewHolder);
    }
        
    public boolean canReuseUpdatedViewHolder(@NonNull ViewHolder viewHolder) {
    
    
        return true;
    }

canReuseUpdatedViewHolder方法的返回值表示的不同含义如下：

• true，表示可以重用原先的ViewHolder对象
• false，表示应该创建该ViewHolder的副本，以便itemAnimator利用两者来实现动画效果（例如交叉淡入淡出效果）。

简单讲就是，mChangedScrap主要是为列表项数据发生变化时的动画效果服务的。
而mAttachedScrap应对的则是剩下的绝大部分场景，比如：

• 像notifyItemMoved、notifyItemRemoved这种列表项发生移动，但列表项数据本身没有发生变化的场景。
• 关闭了列表项动画，或者列表项动画的canReuseUpdatedViewHolder方法返回true，即允许重用原先的ViewHolder对象的场景。

下面以一个简单的notifyItemRemoved(int position)操作为例来演示:
notifyItemRemoved(int position)方法用于通知观察者，先前位于position的列表项已被移除， 其往后的列表项position都将往前移动1位。
为了简化问题、方便演示，我们的范例将会居于以下限制：

• 列表项总个数没有铺满整个屏幕——意味着不会触发mCachedViews、mRecyclerPool等结构的缓存操作
• 去除列表项动画——意味着调用notifyItemRemoved后RecyclerView只会重新布局子视图一次

recyclerView.itemAnimator = null

理想情况下，调用notifyItemRemoved(int position)方法后，应只有位于position的列表项会被移除，其他的列表项，无论是位于position之前或之后，都最多只会调整position值，而不应发生视图的重新创建或数据的重新绑定，即不应该回调onCreateViewHolder与onBindViewHolder这2个方法。
为此，我们就需要将当前屏幕内的可见列表项暂时从当前屏幕剥离，临时缓存到mAttachedScrap这个结构中去。

等到RecyclerView重新开始布局显示其子视图后，再遍历mAttachedScrap找到对应position的ViewHolder对象进行复用。

2、mCachedViews

mCachedViews主要用于「存放已被移出屏幕、但有可能很快重新进入屏幕的列表项」。其同样是以ArrayList的形式持有着每个列表项的ViewHolder对象，默认大小限制为2。

final ArrayList<ViewHolder> mCachedViews = new ArrayList<ViewHolder>();
int mViewCacheMax = DEFAULT_CACHE_SIZE;
static final int DEFAULT_CACHE_SIZE = 2;

比如像朋友圈这种按更新时间的先后顺序展示的Feed流，我们经常会在快速滑动中确定是否有自己感兴趣的内容，当意识到刚才滑走的内容可能比较有趣时，我们往往就会将上一条内容重新滑回来查看。
这种场景下我们追求的自然是上一条内容展示的实时性与完整性，而不应让用户产生“才滑走那么一会儿又要重新加载”的抱怨，也即同样不应发生视图的重新创建或数据的重新绑定。
我们用几张流程示意图来演示这种情况：
同样为了简化问题、方便描述，我们的范例将会居于以下限制：

• 关闭预拉取——意味着之后向上滑动时，都不会再预拉取「待进入屏幕区域」的一个列表项放入mCachedView了

recyclerView.layoutManager?.isItemPrefetchEnabled = false

• 只存在一种类型的列表项，即所有列表项的itemType相同，默认都为0。
  我们将图中的列表项分成了3块区域，分别是被滑出屏幕之外的区域、屏幕内的可见区域、随着滑动手势待进入屏幕的区域。
  

1、当position=0的列表项随着向上滑动的手势被移出屏幕后，由于mCachedViews初始容量为0，因此可直接放入；

2、当position=1的列表项同样被移出屏幕后，由于未达到mCachedViews的默认容量大小限制，因此也可继续放入；

3、此时改为向下滑动，position=1的列表项重新进入屏幕，Recycler就会依次从mAttachedScrap、mCachedViews查找可重用于此位置的ViewHolder对象；
4、mAttachedScrap不是应对这种情况的，自然找不到。而mCachedViews会遍历自身持有的ViewHolder对象，对比ViewHolder对象的position值与待复用位置的position值是否一致，是的话就会将ViewHolder对象从mCachedViews中移除并返回；
5、此处拿到的ViewHolder对象即可直接复用，即符合前面所述的「最优情况」。

6、另外，随着position=1的列表项重新进入屏幕，position=7的列表项也会被移出屏幕，该位置的列表项同样会进入mCachedViews，即RecyclerView是双向缓存的。

3、mViewCacheExtension

mViewCacheExtension主要用于提供额外的、可由开发人员自由控制的缓存层级，属于非常规使用的情况，因此这里暂不展开讲。

4、mRecyclerPool

mRecyclerPool主要用于「按不同的itemType分别存放超出mCachedViews限制的、被移出屏幕的列表项」，其会先以SparseArray区分不同的itemType，然后每种itemType对应的值又以ArrayList的形式持有着每个列表项的ViewHolder对象，每种itemType的ArrayList大小限制默认为5。

  public static class RecycledViewPool {
    
    
        private static final int DEFAULT_MAX_SCRAP = 5;
        static class ScrapData {
    
    
            final ArrayList<ViewHolder> mScrapHeap = new ArrayList<>();
            int mMaxScrap = DEFAULT_MAX_SCRAP;
            long mCreateRunningAverageNs = 0;
            long mBindRunningAverageNs = 0;
        }
        SparseArray<ScrapData> mScrap = new SparseArray<>();
        ...
    }

由于mCachedViews默认的大小限制仅为2，因此，当滑出屏幕的列表项超过2个后，就会按照先进先出的顺序，依次将ViewHolder对象从mCachedViews移出，并按itemType放入RecycledViewPool中的不同ArrayList。
这种缓存结构主要考虑的是随着被滑出屏幕列表项的增多，以及被滑出距离的越来越远，重新进入屏幕内的可能性也随之降低。于是Recycler就在时间与空间上做了一个权衡，允许相同itemType的ViewHolder被提取复用，只需要重新绑定数据即可。
这样一来，既可以避免无限增长的ViewHolder对象缓存挤占了原本就紧张的内存空间，又可以减少回调相比较之下执行代价更加昂贵的onCreateViewHolder方法。
同样我们用几张流程示意图来演示这种情况，这些示意图将在前面的mCachedViews示意图基础上继续操作：
1、假设目前存在于mCachedViews中的仍是position=0及position=1这两个列表项。
2、当我们继续向上滑动时，position=2的列表项会尝试进入mCachedViews，由于超出了mCachedViews的容量限制，position=0的列表项会从mCachedViews中被移出，并放入RecycledViewPool中itemType为0的ArrayList，即图中的情况①；

3、同时，底部的一个新的列表项也将随着滑动手势进入到屏幕内，但由于此时mAttachedScrap、mCachedViews、mRecyclerPool均没有合适的ViewHolder对象可以提供给其复用，因此该列表项只能执行onCreateViewHolder与onBindViewHolder这2个方法的回调，即图中的情况②；
4、等到position=2的列表项被完全移出了屏幕后，也就顺利进入了mCachedViews中。

5、我们继续保持向上滑动的手势，此时，由于下一个待进入屏幕的列表项与position=0的列表项的itemType相同，因此我们可以在走到从mRecyclerPool查找合适的ViewHolder对象这一步时，根据itemType找到对应的ArrayList，再取出其中的1个ViewHolder对象进行复用，即图中的情况①。
6、由于itemType类型一致，其关联的视图可以复用，因此只需要重新绑定数据即可，即符合前面所述的「次优情况」。

7、②③ 情况与前面的一致，此处不再赘述。

四、预加载

RecyclerView默认会通过GapWorker实现预加载功能，以提高滑动时的流畅度和用户体验。

GapWorker在RecyclerView滚动时会异步地预取屏幕外的项目，填充屏幕空白区域，确保这些项目在需要展示时已经被预加载。这个实现在RecyclerView内部已经进行了优化，可以保证高效且准确地填充可见区域的空白部分。同时，可以通过设置RecyclerView的一些参数，例如setInitialPrefetchItemCount()和setItemPrefetchEnabled()等来控制预加载的数量和优先级等方面的内容。

预加载默认加载的ViewHolder数量是滑动方向上的屏幕数量，即RecyclerView可见区域内的ViewHolder数目。

例如，如果RecyclerView的方向是垂直滑动，每次预加载会加载当前可见区域在上方和下方一屏的ViewHolder，即预加载两屏。

如果RecyclerView的方向是水平滑动，每次预加载会加载当前可见区域在左侧和右侧一屏的ViewHolder，即预加载两屏。

这样可以保证用户滑动到新的区域时，预加载的ViewHolder已经准备好，不会出现卡顿的情况，提升用户体验。当然，这个数字是可以通过调整RecyclerView.PREFETCHING_COUNT_DEFAULT属性来进行修改的。

看图来理解一下：
1、利用UI线程正好处于空闲状态的时机

2、预先拉取待进入屏幕区域内的一部分列表项视图并缓存起来

3、从而减少因视图创建或数据绑定等耗时操作所引起的卡顿。

所以：我们的第二层的缓存mCachedViews中不仅有我们的离开屏幕缓存的ViewHolder。还有我们预备拉取的ViewHolder。
缓存复用的对象和预拉取的对象共用同一个mCachedViews结构，但二者是分组存放的，且缓存复用的对象是排在预拉取的对象前面的

	预加载机制
概念	利用UI线程正好处于空闲状态的时机，预先拉取一部分列表项视图并缓存起来，从而减少因视图创建或数据绑定等耗时操作所引起的卡顿。
重要类	GapWorker：综合滑动方向、滑动速度、与可见区域的距离等要素，构建并调度预拉取任务列表。
	Recycler：获取ViewHolder对象，如果缓存中找不到，则重新创建并绑定
结构	mCachedViews：顺利获取到了ViewHolder对象，且已完成数据的绑定时放入
	mRecyclerPool：顺利获取到了ViewHolder对象，但还未完成数据的绑定时放入
发起时机	被拖动(Drag)、惯性滑动(Fling)、嵌套滚动时
完成期限	下一个垂直同步信号发出之前

五、总结

RecyclerView缓存复用机制
对象	ViewHolder(包含列表项视图(itemView)的封装容器)
目的	减少对onCreateViewHolder、onBindViewHolder这2个方法的回调
好处	1.避免重复创建不必要的视图 2.避免重复执行昂贵的findViewById
效果	改善性能、提升应用响应能力、降低功耗
核心类	Recycler、RecyclerViewPool
缓存结构	mChangedScrap/mAttachedScrap、mCachedViews、mViewCacheExtension、mRecyclerPool

缓存结构	容器类型	容量限制	缓存用途	是否回调createView	是否回调bindView
mChangedScrap/mAttachedScrap	ArrayList	无，一般为屏幕内总的可见列表项数	存放已被移出屏幕、但有可能很快重新进入屏幕的列表项	否	否
mCachedViews	ArrayList	默认为2	临时存放仍在当前屏幕可见、但被标记为「移除」或「重用」的列表项	否	否
mViewCacheExtension	开发者自己定义	无	提供额外的可由开发人员自由控制的缓存层级	否	否
mRecyclerPool	SparseArray	每种itemType默认为5	按不同的itemType分别存放超出mCachedViews限制的、被移出屏幕的列表项	否	是