咱们晓得，RecyclerView 在大量数据时仍然能够丝滑般顺畅的滑动，那它到底是怎么实现的呢，而 RecyclerView 之所以好用得益于它优良的缓存机制。

咱们晓得，RecyclerView 自身是一个 ViewGroup，因而在滑动时就防止不了增加或移除子 View(子 View 通过 RecyclerView#Adapter 中的 onCreateViewHolder 创立)，如果每次应用子 View 都要去从新创立，必定会影响滑动的流畅性，所以 RecyclerView 通过 Recycler 来缓存的是 ViewHolder(外部蕴含子 View)，这样在滑动时能够复用子 View，某些条件下还能够复用子 View 绑定的数据。所以实质上来说，RecyclerView 之所以可能实现顺畅的滑动成果，是因为缓存机制，因为缓存缩小了反复绘制 View 和绑定数据的工夫，从而进步了滑动时的性能。

一、缓存

1.1、四级缓存

Recycler 缓存 ViewHolder 对象有 4 个等级，优先级从高到底顺次为：

• mAttachedScrap：缓存屏幕中可见范畴的 ViewHolder；
• mCachedViews：缓存滑动时行将与 RecyclerView 拆散的 ViewHolder，默认最大 2 个；
• ViewCacheExtension：自定义实现的缓存；
• RecycledViewPool：ViewHolder 缓存池，能够反对不同的 ViewType；

1.1.1 mAttachedScrap

mAttachedScrap 存储的是以后屏幕中的 ViewHolder，mAttachedScrap 的对应数据结构是 ArrayList，在调用 LayoutManager#onLayoutChildren 办法时对 views 进行布局，此时会将 RecyclerView 上的 Views 全副暂存到该汇合中，该缓存中的 ViewHolder 的个性是，如果和 RV 上的 position 或者 itemId 匹配上了那么能够间接拿来应用的，无需调用 onBindViewHolder 办法。

1.1.2 mChangedScrap

mChangedScrap 和 mAttachedScrap 属于同一级别的缓存，不过 mChangedScrap 的调用场景是 notifyItemChanged 和 notifyItemRangeChanged，只有发生变化的 ViewHolder 才会放入到 mChangedScrap 中。mChangedScrap 缓存中的 ViewHolder 是须要调用 onBindViewHolder 办法从新绑定数据的。

1.1.3 mCachedViews

mCachedViews 缓存滑动时行将与 RecyclerView 拆散的 ViewHolder，按子 View 的 position 或 id 缓存，默认最多寄存 2 个。mCachedViews 对应的数据结构是 ArrayList，然而该缓存对汇合的大小是有限度的。

该缓存中 ViewHolder 的个性和 mAttachedScrap 中的个性是一样的，只有 position 或者 itemId 对应就无需从新绑定数据。开发者能够调用 setItemViewCacheSize(size) 办法来扭转缓存的大小，该层级缓存触发的一个常见的场景是滑动 RecyclerView。当然调用 notify() 也会触发该缓存。

1.1.4 ViewCacheExtension

ViewCacheExtension 是须要开发者本人实现的缓存，基本上页面上的所有数据都能够通过它进行实现。

1.1.5 RecyclerViewPool

ViewHolder 缓存池，实质上是一个 SparseArray，其中 key 是 ViewType(int 类型)，value 寄存的是 ArrayList< ViewHolder>，默认每个 ArrayList 中最多寄存 5 个 ViewHolder。

1.2 四级缓存比照

1.3 调用过程

通常，RecyclerView 滑动时会触发 onTouchEvent#onMove，回收及复用 ViewHolder 在这里就会开始。咱们晓得设置 RecyclerView 时须要设置 LayoutManager,LayoutManager 负责 RecyclerView 的布局，蕴含对 ItemView 的获取与复用。以 LinearLayoutManager 为例，当 RecyclerView 从新布局时会顺次执行上面几个办法：

• onLayoutChildren()：对 RecyclerView 进行布局的入口办法
• fill(): 负责对残余空间一直地填充，调用的办法是 layoutChunk()
• layoutChunk()：负责填充 View, 该 View 最终是通过在缓存类 Recycler 中找到适合的 View 的

上述的整个调用链：onLayoutChildren()->fill()->layoutChunk()->next()->getViewForPosition(),getViewForPosition() 即是是从 RecyclerView 的回收机制实现类 Recycler 中获取适合的 View。

二、复用流程

RecyclerView 对 ViewHolder 的复用是从 LayoutState 的 next() 办法开始的。LayoutManager 在布局 itemView 时，须要获取一个 ViewHolder 对象，如下所示。

        View next(RecyclerView.Recycler recycler) {if (mScrapList != null) {return nextViewFromScrapList();
            }
            final View view = recycler.getViewForPosition(mCurrentPosition);
            mCurrentPosition += mItemDirection;
            return view;
        }

next 办法调用 RecyclerView 的 getViewForPosition 办法来获取一个 View，而 getViewForPosition 办法最终会调用到 RecyclerView 的 tryGetViewHolderForPositionByDeadline 办法，而 RecyclerView 真正复用的外围就在这里。

    @Nullable
    ViewHolder tryGetViewHolderForPositionByDeadline(int position, boolean dryRun, long deadlineNs) {
        ViewHolder holder = null;
        // 0) 如果它是扭转的废除的 ViewHolder，在 scrap 的 mChangedScrap 找
        if (mState.isPreLayout()) {holder = getChangedScrapViewForPosition(position);
            fromScrapOrHiddenOrCache = holder != null;
        }
        // 1) 依据 position 别离在 scrap 的 mAttachedScrap、mChildHelper、mCachedViews 中查找
        if (holder == null) {holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
        }

        if (holder == null) {final int type = mAdapter.getItemViewType(offsetPosition);
            // 2) 依据 id 在 scrap 的 mAttachedScrap、mCachedViews 中查找
            if (mAdapter.hasStableIds()) {holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition), type, dryRun);
            }
            if (holder == null && mViewCacheExtension != null) {//3) 在 ViewCacheExtension 中查找，个别不必到，所以没有缓存
                final View view = mViewCacheExtension
                        .getViewForPositionAndType(this, position, type);
                if (view != null) {holder = getChildViewHolder(view);
                }
            }
            //4) 在 RecycledViewPool 中查找
            holder = getRecycledViewPool().getRecycledView(type);
            if (holder != null) {holder.resetInternal();
                if (FORCE_INVALIDATE_DISPLAY_LIST) {invalidateDisplayListInt(holder);
                }
            }
        }
        //5) 到最初如果还没有找到复用的 ViewHolder，则新建一个
        holder = mAdapter.createViewHolder(RecyclerView.this, type);
    }

能够看到，tryGetViewHolderForPositionByDeadline() 办法别离去 scrap、CacheView、ViewCacheExtension、RecycledViewPool 中获取 ViewHolder，如果没有则创立一个新的 ViewHolder。

2.1 getChangedScrapViewForPosition

个别状况下，当咱们调用 adapter 的 notifyItemChanged() 办法，数据发生变化时，item 缓存在 mChangedScrap 中，后续拿到的 ViewHolder 须要从新绑定数据。此时查找 ViewHolder 就会通过 position 和 id 别离在 scrap 的 mChangedScrap 中查找。

   ViewHolder getChangedScrapViewForPosition(int position) {
        // 通过 position
        for (int i = 0; i < changedScrapSize; i++) {final ViewHolder holder = mChangedScrap.get(i);
            return holder;
        }
        // 通过 id
        if (mAdapter.hasStableIds()) {final long id = mAdapter.getItemId(offsetPosition);
            for (int i = 0; i < changedScrapSize; i++) {final ViewHolder holder = mChangedScrap.get(i);
                return holder;
            }
        }
        return null;
    }

2.2 getScrapOrHiddenOrCachedHolderForPosition

如果没有找到视图，依据 position 别离在 scrap 的 mAttachedScrap、mChildHelper、mCachedViews 中查找，波及的办法如下。

    ViewHolder getScrapOrHiddenOrCachedHolderForPosition(int position, boolean dryRun) {final int scrapCount = mAttachedScrap.size();

        // 首先从 mAttachedScrap 中查找，精准匹配无效的 ViewHolder
        for (int i = 0; i < scrapCount; i++) {final ViewHolder holder = mAttachedScrap.get(i);
            return holder;
        }
        // 接着在 mChildHelper 中 mHiddenViews 查找暗藏的 ViewHolder
        if (!dryRun) {View view = mChildHelper.findHiddenNonRemovedView(position);
            if (view != null) {final ViewHolder vh = getChildViewHolderInt(view);
                scrapView(view);
                return vh;
            }
        }
        // 最初从咱们的一级缓存中 mCachedViews 查找。final int cacheSize = mCachedViews.size();
        for (int i = 0; i < cacheSize; i++) {final ViewHolder holder = mCachedViews.get(i);
            return holder;
        }
    }

能够看到，getScrapOrHiddenOrCachedHolderForPosition 查找 ViewHolder 的程序如下：

• 首先，从 mAttachedScrap 中查找，精准匹配无效的 ViewHolder；
• 接着，在 mChildHelper 中 mHiddenViews 查找暗藏的 ViewHolder；
• 最初，从一级缓存中 mCachedViews 查找。

2.3 getScrapOrCachedViewForId

如果在 getScrapOrHiddenOrCachedHolderForPosition 没有找到视图，泽通过 id 在 scrap 的 mAttachedScrap、mCachedViews 中查找，代码如下。

  ViewHolder getScrapOrCachedViewForId(long id, int type, boolean dryRun) {
        // 在 Scrap 的 mAttachedScrap 中查找
        final int count = mAttachedScrap.size();
        for (int i = count - 1; i >= 0; i--) {final ViewHolder holder = mAttachedScrap.get(i);
            return holder;
        }

        // 在一级缓存 mCachedViews 中查找
        final int cacheSize = mCachedViews.size();
        for (int i = cacheSize - 1; i >= 0; i--) {final ViewHolder holder = mCachedViews.get(i);
            return holder;
        }
    }        

getScrapOrCachedViewForId() 办法查找的程序如下：

• 首先，从 mAttachedScrap 中查找，精准匹配无效的 ViewHolder；
• 接着，从一级缓存中 mCachedViews 查找；

2.4 mViewCacheExtension

mViewCacheExtension 是由开发者定义的一层缓存策略，Recycler 并没有将任何 view 缓存到这里。

if (holder == null && mViewCacheExtension != null) {final View view = mViewCacheExtension.getViewForPositionAndType(this, position, type);
        if (view != null) {holder = getChildViewHolder(view);
        }
    }

这里没有自定义缓存策略，那么就找不到对应的 view。

2.5 RecycledViewPool

在 ViewHolder 的四级缓存中，咱们有提到过 RecycledViewPool，它是通过 itemType 把 ViewHolder 的 List 缓存到 SparseArray 中的，在 getRecycledViewPool().getRecycledView(type) 依据 itemType 从 SparseArray 获取 ScrapData，而后再从外面获取 ArrayList<ViewHolder>，从而获取到 ViewHolder。

    @Nullable
    public ViewHolder getRecycledView(int viewType) {final ScrapData scrapData = mScrap.get(viewType);// 依据 viewType 获取对应的 ScrapData 
        if (scrapData != null && !scrapData.mScrapHeap.isEmpty()) {
            final ArrayList<ViewHolder> scrapHeap = scrapData.mScrapHeap;
            for (int i = scrapHeap.size() - 1; i >= 0; i--) {if (!scrapHeap.get(i).isAttachedToTransitionOverlay()) {return scrapHeap.remove(i);
                }
            }
        }
        return null;
    }

2.6 创立新的 ViewHolder

如果还没有获取到 ViewHolder，则通过 mAdapter.createViewHolder() 创立一个新的 ViewHolder 返回。

  // 如果还没有找到复用的 ViewHolder，则新建一个
  holder = mAdapter.createViewHolder(RecyclerView.this, type);

上面是寻找 ViewHolder 的一个残缺的流程图：

三、回收流程

RecyclerView 回收的入口有很多，然而不论怎么样操作，RecyclerView 的回收或者复用必然波及到 add View 和 remove View 操作，所以咱们从 onLayout 的流程动手剖析回收和复用的机制。

首先，在 LinearLayoutManager 中，咱们来到 itemView 布局入口的办法 onLayoutChildren()，如下所示。

    @Override
    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {if (mPendingSavedState != null || mPendingScrollPosition != RecyclerView.NO_POSITION) {if (state.getItemCount() == 0) {removeAndRecycleAllViews(recycler);// 移除所有子 View
                return;
            }
        }
        ensureLayoutState();
        mLayoutState.mRecycle = false;// 禁止回收
        // 颠倒绘制布局
        resolveShouldLayoutReverse();
        onAnchorReady(recycler, state, mAnchorInfo, firstLayoutDirection);

        // 临时拆散曾经附加的 view，行将所有 child detach 并通过 Scrap 回收
        detachAndScrapAttachedViews(recycler);
    }

在 onLayoutChildren() 布局的时候，先依据理论状况是否须要 removeAndRecycleAllViews() 移除所有的子 View，哪些 ViewHolder 不可用；而后通过 detachAndScrapAttachedViews() 临时拆散曾经附加的 ItemView，并缓存到 List 中。

detachAndScrapAttachedViews() 的作用就是把以后屏幕所有的 item 与屏幕拆散，将他们从 RecyclerView 的布局中拿下来，保留到 list 中，在从新布局时，再将 ViewHolder 从新一个个放到新的地位下来。

将屏幕上的 ViewHolder 从 RecyclerView 的布局中拿下来后，寄存在 Scrap 中，Scrap 包含 mAttachedScrap 和 mChangedScrap，它们是一个 list，用来保留从 RecyclerView 布局中拿下来 ViewHolder 列表，detachAndScrapAttachedViews() 只会在 onLayoutChildren() 中调用，只有在布局的时候，才会把 ViewHolder detach 掉，而后再 add 进来从新布局，然而大家须要留神，Scrap 只是保留从 RecyclerView 布局中以后屏幕显示的 item 的 ViewHolder，不参加回收复用，单纯是为了现从 RecyclerView 中拿下来再从新布局下来。对于没有保留到的 item，会放到 mCachedViews 或者 RecycledViewPool 缓存中参加回收复用。

   public void detachAndScrapAttachedViews(@NonNull Recycler recycler) {final int childCount = getChildCount();
        for (int i = childCount - 1; i >= 0; i--) {final View v = getChildAt(i);
            scrapOrRecycleView(recycler, i, v);
        }
    }

下面代码的作用是，遍历所有 view，拆散所有曾经增加到 RecyclerView 的 itemView。

   private void scrapOrRecycleView(Recycler recycler, int index, View view) {final ViewHolder viewHolder = getChildViewHolderInt(view);
        if (viewHolder.isInvalid() && !viewHolder.isRemoved()
                && !mRecyclerView.mAdapter.hasStableIds()) {removeViewAt(index);// 移除 VIew
            recycler.recycleViewHolderInternal(viewHolder);// 缓存到 CacheView 或者 RecycledViewPool 中
        } else {detachViewAt(index);// 拆散 View
            recycler.scrapView(view);//scrap 缓存
            mRecyclerView.mViewInfoStore.onViewDetached(viewHolder);
        }
    }

而后，咱们看 detachViewAt() 办法拆散视图，再通过 scrapView() 缓存到 scrap 中。

    void scrapView(View view) {final ViewHolder holder = getChildViewHolderInt(view);
        if (holder.hasAnyOfTheFlags(ViewHolder.FLAG_REMOVED | ViewHolder.FLAG_INVALID)
                || !holder.isUpdated() || canReuseUpdatedViewHolder(holder)) {holder.setScrapContainer(this, false);
            mAttachedScrap.add(holder);// 保留到 mAttachedScrap 中
        } else {if (mChangedScrap == null) {mChangedScrap = new ArrayList<ViewHolder>();
            }
            holder.setScrapContainer(this, true);
            mChangedScrap.add(holder);// 保留到 mChangedScrap 中
        }
    }

而后，咱们回到 scrapOrRecycleView() 办法中，进入 if() 分支。如果 viewHolder 是有效、未被移除、未被标记的则放到 recycleViewHolderInternal() 缓存起来，同时 removeViewAt() 移除了 viewHolder。

   void recycleViewHolderInternal(ViewHolder holder) {
           ·····
        if (forceRecycle || holder.isRecyclable()) {
            if (mViewCacheMax > 0
                    && !holder.hasAnyOfTheFlags(ViewHolder.FLAG_INVALID
                    | ViewHolder.FLAG_REMOVED
                    | ViewHolder.FLAG_UPDATE
                    | ViewHolder.FLAG_ADAPTER_POSITION_UNKNOWN)) {int cachedViewSize = mCachedViews.size();
                if (cachedViewSize >= mViewCacheMax && cachedViewSize > 0) {// 如果超出容量限度，把第一个移除
                    recycleCachedViewAt(0);
                    cachedViewSize--;
                }
                     ·····
                mCachedViews.add(targetCacheIndex, holder);//mCachedViews 回收
                cached = true;
            }
            if (!cached) {addViewHolderToRecycledViewPool(holder, true);// 放到 RecycledViewPool 回收
                recycled = true;
            }
        }
    }

如果符合条件，会优先缓存到 mCachedViews 中时，如果超出了 mCachedViews 的最大限度，通过 recycleCachedViewAt() 将 CacheView 缓存的第一个数据增加到终极回收池 RecycledViewPool 后再移除掉，最初才会 add() 新的 ViewHolder 增加到 mCachedViews 中。

剩下不符合条件的则通过 addViewHolderToRecycledViewPool() 缓存到 RecycledViewPool 中。

    void addViewHolderToRecycledViewPool(@NonNull ViewHolder holder, boolean dispatchRecycled) {clearNestedRecyclerViewIfNotNested(holder);
        View itemView = holder.itemView;
        ······
        holder.mOwnerRecyclerView = null;
        getRecycledViewPool().putRecycledView(holder);// 将 holder 增加到 RecycledViewPool 中
    }

最初，就是在填充布局调用 fill() 办法的时候，它会回收移出屏幕的 view 到 mCachedViews 或者 RecycledViewPool 中。

 int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
            RecyclerView.State state, boolean stopOnFocusable) {if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {recycleByLayoutState(recycler, layoutState);// 回收移出屏幕的 view
        }
    }

而 recycleByLayoutState() 办法就是用来回收移出屏幕的 view，残缺的流程如下图。