深入简出RecyclerView缓存机制

1.RecyclerView基础组件

核心类	作用
LayoutManager	管理ItemView的布局显示
ViewHodler	ItemView的容器
ItemDecoration	ItemView边界绘制，比如分割线
ItemAnimator	ItemView的添加、删除、移动动画
Recycler	管理ItemView的回收和复用

2.RecyclerView与ListView的差异


实现了可回收复用的ViewHolder
实现的Adapter返回的是ViewHolder而不是View
通过LayoutManager来统一管理布局
实现了针对Item的增删动画ItemAnimator类
实现了针对Item间隔的配置ItemDecoration类
支持局部刷新

3.RecyclerView的四级缓存

层级	参数	使用场景
一级	mAttachedScrap	添加和删除ItemView刷新界面时使用
一级	mChangedScrap	执行动画时使用
二级	mCachedViews	默认容量是2，超过时会被保存到mRecyclerPool,ItemView超出屏幕范围后先回收到mCachedViews
三级	mViewCacheExtension	开发者自己扩展使用
四级	mRecyclerPool	当mCachedViews缓存满时，默认每个type类型最多缓存5个

4.RecyclerView缓存策略分析

Recyclerview版本：

implementation "androidx.recyclerview:recyclerview:1.2.1"

接下来通过一个简单的Demo来验证分析RecyclerView的缓存策略

    private void initView(View root) {
        mRecyclerView = root.findViewById(R.id.recycler_view);
        mRecyclerView.setAdapter(new FVAdapter());
        GridLayoutManager layoutManager = new GridLayoutManager(getActivity(), 1);
        layoutManager.setItemPrefetchEnabled(false);
        mRecyclerView.setLayoutManager(layoutManager);
    }

    private void initData() {
        mData = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            mData.add(i);
        }
    }

    public class FVAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

        @NonNull
        @Override
        public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
            Button view = new Button(getActivity());
            view.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 216));
            Log.d(TAG, "onCreateViewHolder");
            return new VH(view);
        }

        @SuppressLint({"SetTextI18n", "ResourceAsColor"})
        @Override
        public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
            VH vh = (VH) holder;
            Button view = (Button) vh.itemView;
            view.setText("View Position:" + position + "\nHolder Index:" + vh.vh_index);
            Log.d(TAG, "onBindViewHolder view position:" + position + " Holder Index:" + vh.vh_index);
        }

        @Override
        public void onViewRecycled(@NonNull RecyclerView.ViewHolder holder) {
            super.onViewRecycled(holder);
            VH vh = (VH) holder;
            Log.d(TAG, "onViewRecycled Holder Index:" + vh.vh_index);
        }

        @Override
        public int getItemCount() {
            return mData.size();
        }
    }

    public int index = 0;

    public class VH extends RecyclerView.ViewHolder {
        public int vh_index;

        public VH(@NonNull View itemView) {
            super(itemView);
            vh_index = index++;
        }
    }

Demo代码很简单，创建1000个Item，每个Item上显示位置和ViewHolder的下标。每屏最多显示5个Item：

mAttachedScrap、mChangedScrap仅在触发onLayout时影响缓存，在滚动场景下，分析流程时可先排除对缓存的影响。

onLayout.png

另外，LayoutManager有两个默认属性，会影响缓存策略：

        public final void setItemPrefetchEnabled(boolean enabled) {
            if (enabled != mItemPrefetchEnabled) {
                mItemPrefetchEnabled = enabled;
                mPrefetchMaxCountObserved = 0;
                if (mRecyclerView != null) {
                    mRecyclerView.mRecycler.updateViewCacheSize();
                }
            }
        }

    /**
     * Number of items to prefetch when first coming on screen with new data.
     */
    private int mInitialPrefetchItemCount = 2;

    public void setInitialPrefetchItemCount(int itemCount) {
        mInitialPrefetchItemCount = itemCount;
    }

从定义上看，mCacheViews的size默认为2，mRecyclerPool的每个Type对应的size默认为5个。

  int mViewCacheMax = DEFAULT_CACHE_SIZE;
  static final int DEFAULT_CACHE_SIZE = 2;

  public static class RecycledViewPool {
        private static final int DEFAULT_MAX_SCRAP = 5;
        ...
  }

为了方便分析，设置setItemPrefetchEnabled(false)，排除缓存size动态变化对分析流程的额外影响：

Recycler.png


1	mCacheViews和mRecyclerPool中未命中缓存，新建一个ViewHolder
2	mCacheViews中有缓存，但是位置不匹配，未命中缓存，新建一个ViewHolder
3	mCacheViews中满缓存，但是位置不匹配，未命中缓存，新建一个ViewHolder
4	mCacheViews中满缓存，但是位置不匹配；mRecyclerPool有缓存，命中type对应的缓存，使用缓存且调研onBindViewHolder方法

按以上方式分析，理论上在滚动时最多只需要创建8个(5 + 2 + 1)ViewHolder，但事实上是这样吗？
首先看下手机端的手指滑动场景：

 14:50:20.264   onCreateViewHolder
 14:50:20.266   onBindViewHolder view position:0 Holder Index:0
 14:50:20.278   onCreateViewHolder
 14:50:20.278   onBindViewHolder view position:1 Holder Index:1
 14:50:20.283   onCreateViewHolder
 14:50:20.284   onBindViewHolder view position:2 Holder Index:2
 14:50:20.289   onCreateViewHolder
 14:50:20.290   onBindViewHolder view position:3 Holder Index:3
 14:50:20.295   onCreateViewHolder
 14:50:20.295   onBindViewHolder view position:4 Holder Index:4
 14:50:26.702   onCreateViewHolder
 14:50:26.704   onBindViewHolder view position:5 Holder Index:5
 14:50:26.749   onCreateViewHolder
 14:50:26.751   onBindViewHolder view position:6 Holder Index:6
 14:50:26.779   onCreateViewHolder
 14:50:26.780   onBindViewHolder view position:7 Holder Index:7
 14:50:26.786   onViewRecycled Holder Index:0
 14:50:26.788   onBindViewHolder view position:8 Holder Index:0
 14:50:26.801   onViewRecycled Holder Index:1
 14:50:26.803   onBindViewHolder view position:9 Holder Index:1
 14:50:26.810   onViewRecycled Holder Index:2
 14:50:26.811   onBindViewHolder view position:10 Holder Index:2
 14:50:26.823   onViewRecycled Holder Index:3
 14:50:26.825   onBindViewHolder view position:11 Holder Index:3
 14:50:26.840   onViewRecycled Holder Index:4
 14:50:26.843   onBindViewHolder view position:12 Holder Index:4
 14:50:26.874   onViewRecycled Holder Index:5
 14:50:26.876   onBindViewHolder view position:13 Holder Index:5
 14:50:26.890   onViewRecycled Holder Index:6
 14:50:26.892   onBindViewHolder view position:14 Holder Index:6
 14:50:26.907   onViewRecycled Holder Index:7
 14:50:26.909   onBindViewHolder view position:15 Holder Index:7
 14:50:26.923   onViewRecycled Holder Index:0
 14:50:26.926   onBindViewHolder view position:16 Holder Index:0

手指无论如何滚动，最多只创建8个ViewHolder，和预期一致。然而，通过实体键(比如电视端使用遥控器)却出现了不一致的情况：

1.慢速滚动

17:20:56.628  onCreateViewHolder
17:20:56.628  onBindViewHolder view position:0 Holder Index:0
17:20:56.631  onCreateViewHolder
17:20:56.631  onBindViewHolder view position:1 Holder Index:1
17:20:56.634  onCreateViewHolder
17:20:56.635  onBindViewHolder view position:2 Holder Index:2
17:20:56.639  onCreateViewHolder
17:20:56.639  onBindViewHolder view position:3 Holder Index:3
17:20:56.644  onCreateViewHolder
17:20:56.644  onBindViewHolder view position:4 Holder Index:4
17:20:59.294  onCreateViewHolder
17:20:59.294  onBindViewHolder view position:5 Holder Index:5
17:21:00.194  onCreateViewHolder
17:21:00.195  onBindViewHolder view position:6 Holder Index:6
17:21:00.886  onCreateViewHolder
17:21:00.886  onBindViewHolder view position:7 Holder Index:7
17:21:01.157  onViewRecycled Holder Index:0
17:21:01.814  onBindViewHolder view position:8 Holder Index:0
17:21:02.073  onViewRecycled Holder Index:1
17:21:02.624  onBindViewHolder view position:9 Holder Index:1
17:21:02.890  onViewRecycled Holder Index:2
17:21:04.544  onBindViewHolder view position:10 Holder Index:2
17:21:04.808  onViewRecycled Holder Index:3
17:21:06.044  onBindViewHolder view position:11 Holder Index:3
17:21:06.307  onViewRecycled Holder Index:4
17:21:06.973  onBindViewHolder view position:12 Holder Index:4
17:21:07.240  onViewRecycled Holder Index:5
17:21:07.814  onBindViewHolder view position:13 Holder Index:5
17:21:08.073  onViewRecycled Holder Index:6
17:21:08.714  onBindViewHolder view position:14 Holder Index:6
17:21:08.974  onViewRecycled Holder Index:7
17:21:09.583  onBindViewHolder view position:15 Holder Index:7
17:21:09.857  onViewRecycled Holder Index:0
17:21:10.484  onBindViewHolder view position:16 Holder Index:0
17:21:10.758  onViewRecycled Holder Index:1

在实体键慢速滚动场景下，结果与预期一致。

2.快速滚动

17:22:48.759 onCreateViewHolder
17:22:48.760 onBindViewHolder view position:0 Holder Index:0
17:22:48.762 onCreateViewHolder
17:22:48.763 onBindViewHolder view position:1 Holder Index:1
17:22:48.765 onCreateViewHolder
17:22:48.766 onBindViewHolder view position:2 Holder Index:2
17:22:48.769 onCreateViewHolder
17:22:48.770 onBindViewHolder view position:3 Holder Index:3
17:22:48.773 onCreateViewHolder
17:22:48.773 onBindViewHolder view position:4 Holder Index:4
17:22:51.242 onCreateViewHolder
17:22:51.243 onBindViewHolder view position:5 Holder Index:5
17:22:51.298 onCreateViewHolder
17:22:51.298 onBindViewHolder view position:6 Holder Index:6
17:22:51.347 onCreateViewHolder
17:22:51.348 onBindViewHolder view position:7 Holder Index:7
17:22:51.399 onCreateViewHolder
17:22:51.400 onBindViewHolder view position:8 Holder Index:8
17:22:51.455 onCreateViewHolder
17:22:51.455 onBindViewHolder view position:9 Holder Index:9
17:22:51.510 onCreateViewHolder
17:22:51.510 onBindViewHolder view position:10 Holder Index:10
17:22:51.519 onViewRecycled Holder Index:0
17:22:51.551 onBindViewHolder view position:11 Holder Index:0
17:22:51.577 onViewRecycled Holder Index:1
17:22:51.596 onBindViewHolder view position:12 Holder Index:1
17:22:51.627 onViewRecycled Holder Index:2
17:22:51.647 onBindViewHolder view position:13 Holder Index:2
17:22:51.660 onViewRecycled Holder Index:3
17:22:51.699 onBindViewHolder view position:14 Holder Index:3
17:22:51.708 onViewRecycled Holder Index:4
17:22:51.748 onBindViewHolder view position:15 Holder Index:4
17:22:51.758 onViewRecycled Holder Index:5

一共创建了11个ViewHolder，和预期不符，这是为什么呢？

首先，先看看按键事件是如何实现RecyclerView滚动的：

图一

图一中标记1，会根据按键方向找到合适的焦点：

图二

找不到焦点时，会先去查找mCachesView中是否有对应Position的缓存，如果没有再从mRecyclerPool中查找是否对应Type的缓存，如果没有命中缓存，则会新建一个ViewHolder，然后bindViewHolder，这个ViewHolder就是即将获取焦点的ItemView。

查找到可获取焦点的ItemView后，根据图一中的流程，因为要requestFocus，最终会通过标记2流程实现RecyclerView的实现。

再看下postOnAnimation实现：

    public void postOnAnimation(Runnable action) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            attachInfo.mViewRootImpl.mChoreographer.postCallback(
                    Choreographer.CALLBACK_ANIMATION, action, null);
        } else {
            // Postpone the runnable until we know
            // on which thread it needs to run.
            getRunQueue().post(action);
        }
    }

简述下Choreographer绘制流程：

图三.Choreographer绘制流程

因此图一标记2位置实现RecyclerView的滚动是在doFrame队列中CALLBACK_ANIMATION阶段时才得到了处理。

在此滚动阶段才可能完成ViewHolder的回收，流程如下：

图四

以下是一张比较抽象的流程图，主要说明在按键事件下Recycler的大概流程：

图五

有一个关键函数fill，在图二、图四中都会调用到：

    int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
            RecyclerView.State state, boolean stopOnFocusable) {
        // max offset we should set is mFastScroll + available
        final int start = layoutState.mAvailable;
        if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {
            // TODO ugly bug fix. should not happen
            if (layoutState.mAvailable < 0) {
                layoutState.mScrollingOffset += layoutState.mAvailable;
            }
            recycleByLayoutState(recycler, layoutState);
        }
        ...
    }

图二流程调用如下，在未找到可获取焦点子控件失败时尝试填充新的子控件,其中滚动的最大距离maxScroll是RecyclerView最高高度的MAX_SCROLL_FACTOR(三分之一)：

    private static final float MAX_SCROLL_FACTOR = 1 / 3f;
    ...
   @Override
    public View onFocusSearchFailed(View focused, int focusDirection,
            RecyclerView.Recycler recycler, RecyclerView.State state) {
        ...
        final int maxScroll = (int) (MAX_SCROLL_FACTOR * mOrientationHelper.getTotalSpace());
        updateLayoutState(layoutDir, maxScroll, false, state);
        // 在调用fill前把mScrollingOffset置为无效，此次不会回收ViewHolder
        mLayoutState.mScrollingOffset = LayoutState.SCROLLING_OFFSET_NaN;
        mLayoutState.mRecycle = false;
        fill(recycler, mLayoutState, state, true);
        ...
    }

图四流程调用如下，在滚动时尝试填充新的子控件：

    int scrollBy(int delta, RecyclerView.Recycler recycler, RecyclerView.State state) {
        ...
        updateLayoutState(layoutDirection, absDelta, true, state);
        final int consumed = mLayoutState.mScrollingOffset
                + fill(recycler, mLayoutState, state, false);
        ...
        final int scrolled = absDelta > consumed ? layoutDirection * consumed : delta;
        // 真正实现视觉上的滚动效果
        mOrientationHelper.offsetChildren(-scrolled); 
        ...
    }

    private void updateLayoutState(int layoutDirection, int requiredSpace,
            boolean canUseExistingSpace, RecyclerView.State state) {
        ...
        mLayoutState.mScrollingOffset = scrollingOffset;
    }

从上面的源码可以看到只有在完成滚动后才可能进行ViewHolder的回收。
可知快速滚动场景下，由于按键事件不断触发，若不能命中缓存，就会不断新建ViewHolder；而只有RecyclerView的滚动需要等到下一次doFrame时才会执行，此后才会决定是否回收ViewHolder。

那么来分析下RecycleView的滚动的具体实现。
实际上RecycleView是在doFrame中一点一点像素滚动的，滚动的距离是通过时间和距离计算出来的：

        //计算此次滚动所需要的时间
        private int computeScrollDuration(int dx, int dy) {
            final int absDx = Math.abs(dx);
            final int absDy = Math.abs(dy);
            final boolean horizontal = absDx > absDy;
            final int containerSize = horizontal ? getWidth() : getHeight();

            float absDelta = (float) (horizontal ? absDx : absDy);
            final int duration = (int) (((absDelta / containerSize) + 1) * 300);

            return Math.min(duration, MAX_SCROLL_DURATION);
        }

可以看到动画的时间是通过滚动距离计算出来的，并且一定大于300ms。

   //计算此次滚动时刻可以滚动的距离
   public boolean computeScrollOffset() {
        if (isFinished()) {
            return false;
        }

        switch (mMode) {
            case SCROLL_MODE:
                long time = AnimationUtils.currentAnimationTimeMillis();
                // Any scroller can be used for time, since they were started
                // together in scroll mode. We use X here.
                final long elapsedTime = time - mScrollerX.mStartTime;

                final int duration = mScrollerX.mDuration;
                if (elapsedTime < duration) {
                    final float q = mInterpolator.getInterpolation(elapsedTime / (float) duration);
                    mScrollerX.updateScroll(q);
                    mScrollerY.updateScroll(q);
                } else {
                    abortAnimation();
                }
                break;
                ...
        }

        return true;
    }

根据图四的流程，再来看看回收ViewHodler的条件, 以列表向上滚动为例：

    private void recycleViewsFromStart(RecyclerView.Recycler recycler, int scrollingOffset,
                                       int noRecycleSpace) {
        ...
        // ignore padding, ViewGroup may not clip children.
        final int limit = scrollingOffset - noRecycleSpace;            ...
            for (int i = 0; i < childCount; i++) {
                View child = getChildAt(i);
                if (mOrientationHelper.getDecoratedEnd(child) > limit
                        || mOrientationHelper.getTransformedEndWithDecoration(child) > limit) {
                    // stop here
                    recycleChildren(recycler, 0, i);
                    return;
                }
            }
        }
    }
    ...
    private void recycleChildren(RecyclerView.Recycler recycler, int startIndex, int endIndex) {
        ...
        if (endIndex > startIndex) {
            for (int i = endIndex - 1; i >= startIndex; i--) {
                removeAndRecycleViewAt(i, recycler);
            }
        } else {
            for (int i = startIndex; i > endIndex; i--) {
                removeAndRecycleViewAt(i, recycler);
            }
        }
    }

被回收的ViewHolder根据type类型放在List的尾部

        public void putRecycledView(ViewHolder scrap) {
            final int viewType = scrap.getItemViewType();
            final ArrayList<ViewHolder> scrapHeap = getScrapDataForType(viewType).mScrapHeap;
            if (mScrap.get(viewType).mMaxScrap <= scrapHeap.size()) {
                return;
            }
            if (DEBUG && scrapHeap.contains(scrap)) {
                throw new IllegalArgumentException("this scrap item already exists");
            }
            scrap.resetInternal();
            scrapHeap.add(scrap);
        }

复用ViewHolder时根据type类型取List尾部的第一个

        public ViewHolder getRecycledView(int viewType) {
            final ScrapData scrapData = mScrap.get(viewType);
            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;
        }

回收的关键在于

mOrientationHelper.getDecoratedEnd(child) > limit || mOrientationHelper.getTransformedEndWithDecoration(child) > limit

在这篇文章的Demo中，以上函数是获取child的最底部(包括bottomMargin)位置，当找到第一个底部大于limit的View时，可以回收所有在这个视图以上的ItemView。

其中limit = scrollingOffset - noRecycleSpace，并且noRecycleSpace在本文中为0，从updateLayoutState可以看出scrollingOffset就是在不添加新的View前可滚动的距离。

FastScroll

上图右侧是用户长按方向键下，每响应一个KeyEvent.KEYCODE_DPAD_DOWN事件，会在RecyclerView中addView一次(有可使用缓存则使用缓存，未命中缓存则新建)。左侧是触发滚动流程，在滚动发生前检查是否有子View的底部高度大于limit，从图中可见即是否大于目标滚动距离，只有大于目标滚动距离时才开始回收ViewHolder。因为在滚动动画执行期间(不小于300ms)，如果有按键事件再次触发focusSearch，就会因为addView刷新mScrollingOffset，本应该在动画结束时触发回收的条件将不满足，所以就出现了缓存Size超过预期的现象。

为什么在手指滑动场景时没有这样的现象？

FastFling

从这里看到相比按键事件，在事件触发后并不需要立即就填充子View，而是在doFrame期间填充的，这样就不会出现limit滚动期间被外界修改的问题，因此ViewHolder的Size总是符合预期的。

5.多行多列

试想一下，长按方向键下快速滚动场景下，ViewHolder的创建和回收情况是怎样的？

优化思路

理论上可以优化成Fling滚动，等到滚动结束后再计算焦点所在的位置。

        mRecyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
            boolean mScrolled = false;

            @Override
            public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
                super.onScrollStateChanged(recyclerView, newState);
                if (newState == RecyclerView.SCROLL_STATE_IDLE && mScrolled) {
                    mScrolled = false;
                    View item = recyclerView.findChildViewUnder(0, rowHeight);
                    if (item != null) {
                        item.requestFocus();
                    }
                }
            }

            @Override
            public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
                super.onScrolled(recyclerView, dx, dy);
                if (dx != 0 || dy != 0) {
                    mScrolled = true;
                }
            }
        });

    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (event.getRepeatCount() != 0) {
            if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
                mRecyclerView.fling(0, rowHeight);
            } else if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
                mRecyclerView.fling(0, -rowHeight);
            }
            return true;
        } else {
            return false;
        }
    }

优化前

优化后