其他分享
首页 > 其他分享> > 深入RecyclerView学习—缓存机制

深入RecyclerView学习—缓存机制

作者:互联网

前言

RecyclerView作为替代ListView的组件,得益于RecyclerView的灵活性和可定制程度高的特性。除此之外RecyclerView的预取机制以及缓存机制也是RecyckerView的一大亮点。

RecyclerView的灵活性是通过几个不同的组件协同实现的。

LayoutManager:是布局管理器,用来决定视图如何填充RecyclerView。

RecyclerView.Adapter:适配器是负责提供视图所需要的数据集以及管理视图的创建和数据绑定。

ViewHolder:视图持有者,负责视图的初始化。

RecyclerView除了灵活性外,还执行了大量的优化工作。主要的优化就是缓存机制。接下来就重点学习一下RecyclerView中的缓存机制原理。

RecyclerView缓存机制

缓存工作流程

对于RecyclerView的缓存工作流程在Android文档中也讲的很清楚。

这两点大致描述了RecyclerView的缓存机制。大意就是RecyclerView会缓存滚动出屏幕外的Item并且在有新的Item进入屏幕时不重建新的视图,只绑定新的数据已达到重用的目的。

缓存原理

上一节中简要叙述了RecyclerView缓存机制的工作流程。接下来根据缓存的工作流程再通过源码分析具体的执行逻辑。

RecyclerView中的缓存数据结构

直接说结论,在RecyclerView中的Recycler类中存放着RecyclerView需要的缓存数据结构。

public final class Recycler {
        // Scrap缓存
        final ArrayList<ViewHolder> mAttachedScrap = new ArrayList<>();
        ArrayList<ViewHolder> mChangedScrap = null;
        // Cache缓存
        final ArrayList<ViewHolder> mCachedViews = new ArrayList<ViewHolder>();

        private final List<ViewHolder>
                mUnmodifiableAttachedScrap = Collections.unmodifiableList(mAttachedScrap);

        private int mRequestedCacheMax = DEFAULT_CACHE_SIZE;
        int mViewCacheMax = DEFAULT_CACHE_SIZE;
        // 缓存池
        RecycledViewPool mRecyclerPool;
        // 自定义缓存
        private ViewCacheExtension mViewCacheExtension;

        static final int DEFAULT_CACHE_SIZE = 2; // 对应mCachedViews默认大小
}

上面的代码也很容易看到RecyclerView缓存的位置,这里大概可以分为4种类别:

缓存原理分析

首先看源码是现有大致的思路,根据上面讲到的缓存流程来看,在RecyclerView滑动时会查找缓存中是否有匹配的数据。所以缓存机制的工作是从滑动开始的,那么滑动就会触发View的工作流程(measure、layout、draw)根据接下来这个思路去看代码。

具体特别细节的源码就不再一一叙述,看源码也不是为了记住所有的细节,而是为了学习主要的逻辑跟设计的模式。

RecyclerView的测量、绘制都是委托给LayoutManager的,在LinearLayoutManager中,可以找到相关的代码。

@Override
    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
        //...
        detachAndScrapAttachedViews(recycler);
        //...
    }

在LinearLayoutManager的onLayoutChildren()方法中只截取了这一行代码,它的作用就是处理Scrap缓存以及detach的ViewHolder。

/**
         * Temporarily detach and scrap all currently attached child views. Views will be scrapped
         * into the given Recycler. The Recycler may prefer to reuse scrap views before
         * other views that were previously recycled.
         *
         * @param recycler Recycler to scrap views into
         */
        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);
            }
        }

从代码的注释中写的很清楚处理视图的缓存逻辑;接下来继续分析。

private void scrapOrRecycleView(Recycler recycler, int index, View view) {
            final ViewHolder viewHolder = getChildViewHolderInt(view);
            if (viewHolder.shouldIgnore()) {
                if (DEBUG) {
                    Log.d(TAG, "ignoring view " + viewHolder);
                }
                return;
            }
            if (viewHolder.isInvalid() && !viewHolder.isRemoved()
                    && !mRecyclerView.mAdapter.hasStableIds()) {
                // ViewHolder是indalid的
                removeViewAt(index);
                recycler.recycleViewHolderInternal(viewHolder);
            } else {
                // ViewHolder对应的View是attach的
                detachViewAt(index);
                recycler.scrapView(view);
                mRecyclerView.mViewInfoStore.onViewDetached(viewHolder);
            }
        }

在scrapOrRecycleView()方法中有两个逻辑分支,分别处理在屏幕中的Item以及需要回收的Item。我们先看如何处理屏幕中的Item。

void scrapView(View view) {
            final ViewHolder holder = getChildViewHolderInt(view);
            if (holder.hasAnyOfTheFlags(ViewHolder.FLAG_REMOVED | ViewHolder.FLAG_INVALID)
                    || !holder.isUpdated() || canReuseUpdatedViewHolder(holder)) {
                if (holder.isInvalid() && !holder.isRemoved() && !mAdapter.hasStableIds()) {
                holder.setScrapContainer(this, false);
                mAttachedScrap.add(holder);
            } else {
                if (mChangedScrap == null) {
                    mChangedScrap = new ArrayList<ViewHolder>();
                }
                holder.setScrapContainer(this, true);
                mChangedScrap.add(holder);
            }
        }

这里主要处理的就是将ViewHolder加入Scrap缓存中。接下来分析另一种情况。

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)) {
                    // Retire oldest cached view
                    int cachedViewSize = mCachedViews.size();
                    if (cachedViewSize >= mViewCacheMax && cachedViewSize > 0) {
                        recycleCachedViewAt(0);
                        cachedViewSize--;
                    }

                    int targetCacheIndex = cachedViewSize;
                    //...
                    mCachedViews.add(targetCacheIndex, holder);
                    cached = true;
                }
                if (!cached) {
                    addViewHolderToRecycledViewPool(holder, true);
                    recycled = true;
                }
            }
            //...
        }

recycleViewHolderInternal()方法中主要是对Cache缓存和RecycledViewPool缓存进行处理。判断依据主要是根据ViewHolde的标志位进行判断。

在上面的代码中主要分析了RecyclerView中缓存数据的来源,接下来继续分析如何使用缓存。按照之前的思路,在LayoutManager执行onLayoutChildren()方法时会获取新的Item这个时候就会触发RecyclerView的缓存机制。

@Override
    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
        //...
        fill(recycler, mLayoutState, state, false);
        //...
    }
int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
            RecyclerView.State state, boolean stopOnFocusable) {
    //...
    layoutChunk(recycler, state, layoutState, layoutChunkResult);
    //...
}
void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
            LayoutState layoutState, LayoutChunkResult result) {
    //...
    View view = layoutState.next(recycler);
    //...
}
View next(RecyclerView.Recycler recycler) {
     if (mScrapList != null) {
          return nextViewFromScrapList();
     }
     final View view = recycler.getViewForPosition(mCurrentPosition);
     mCurrentPosition += mItemDirection;
     return view;
}

这次就不啰嗦了,直接把前面需要执行的流程都列了出来,可以看到LayoutManager是通过fill()方法来填充布局的,在这个过程中最终会通过Recycler的getViewForPosition()方法获取到需要添加的View。接下来就从Recycler中进行分析。

在Recycler中获取View的方法最终是在tryGetViewHolderForPositionByDeadline()方法执行的:

ViewHolder tryGetViewHolderForPositionByDeadline(int position,
                boolean dryRun, long deadlineNs) {
            //...
            boolean fromScrapOrHiddenOrCache = false;
            ViewHolder holder = null;
            // 0) If there is a changed scrap, try to find from there
            if (mState.isPreLayout()) {
                holder = getChangedScrapViewForPosition(position);
                fromScrapOrHiddenOrCache = holder != null;
            }
            // 1) Find by position from scrap/hidden list/cache
            if (holder == null) {
                // 1) 获取ViewHolder(从Scrap或者Cache中)
                holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
                //...
            }
            if (holder == null) {
                final int offsetPosition = mAdapterHelper.findPositionOffset(position);
                final int type = mAdapter.getItemViewType(offsetPosition);
                // 2) Find from scrap/cache via stable ids, if exists
                if (mAdapter.hasStableIds()) {
                    // 2) 获取ViewHolder(从Scrap或者Cache中)
                    holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
                            type, dryRun);
                   
                }
                if (holder == null && mViewCacheExtension != null) {
                    // 3) 获取ViewHolder(从ViewCacheExtension中)
                    final View view = mViewCacheExtension
                            .getViewForPositionAndType(this, position, type);
                    //...
                }
                if (holder == null) { // fallback to pool
                     // 4) 获取ViewHolder(从RecycledViewPool中)
                    holder = getRecycledViewPool().getRecycledView(type);
                    if (holder != null) {
                        holder.resetInternal();
                        if (FORCE_INVALIDATE_DISPLAY_LIST) {
                            invalidateDisplayListInt(holder);
                        }
                    }
                }
                if (holder == null) {
                   // 5) 新建ViewHolder
                    holder = mAdapter.createViewHolder(RecyclerView.this, type);
                }
            }
            //...
            return holder;
        }

为了把关注点发在ViewHolder获取的过程中,这里简化大量的代码。从上面注释中可以看到获取ViewHolder的过程总共有5步,其中第1、2步都是从Scrap或者Cache中获取的(其中的区别是第一次是通过position获取,第二次通过id和type获取),第3步从ViewCacheExtension中获取,第4步从从RecycledViewPool中获取,第5步新建ViewHolder。

总结

至此,RecyclerView的缓存原理就介绍完了。这里面并没有深挖细节,而是通过先熟悉RecyclerView缓存的工作流程,进而通过源码来分析RecyclerView缓存的运行机制。

总结来说RecyclerView的缓存都是发生在Layout的过程中,在这里对缓存的数据进行管理,包括缓存的增加、删除、查找等行为。

标签:ViewHolder,recycler,RecyclerView,视图,缓存,深入,holder
来源: https://blog.csdn.net/programerxiaoer/article/details/111767870