解析RecyclerView的缓存机制

最新推荐文章于 2024-08-14 21:11:10 发布
最新推荐文章于 2024-08-14 21:11:10 发布
阅读量605 收藏
点赞数 3
分类专栏： Android重点难点 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36299025/article/details/107376882
版权

文章目录

在使用RecyclerView的时候，都遇到过滑动显示错乱，这时我们分析原因就得从RecyclerView的onTouchEvent方法的ACTION_MOVE事件开始入手。在MOVE事件内调用了scrollByInternal()方法，在scrollByInternal()方法内对x、y分情况调用了mLayout.scrollHorizontallyBy、mLayout.scrollVerticallyBy方法。

这个mLayout指得就是XXXLayoutManager，由于GridLayoutManager是继承自LinearLayoutManager的，所以我们直接看LinearLayoutManager。不管是mLayout.scrollHorizontallyBy还是mLayout.scrollVerticallyBy方法，他们内部最终都是调用的scrollBy()方法，继而调用了fill()方法。

fill()方法就干了两件事：回收 + 复用

fill()方法做的事在这里插入图片描述

复用：layoutChunk(recycler, state, layoutState, layoutChunkResult)

复用流程

void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
        LayoutState layoutState, LayoutChunkResult result) {
    //复用时addView方法添加的Item View
    View view = layoutState.next(recycler);
    if (view == null) {
        if (DEBUG && layoutState.mScrapList == null) {
            throw new RuntimeException("received null view when unexpected");
        }
        // if we are laying out views in scrap, this may return null which means there is
        // no more items to layout.
        result.mFinished = true;
        return;
    }
    LayoutParams params = (LayoutParams) view.getLayoutParams();
    if (layoutState.mScrapList == null) {
        if (mShouldReverseLayout == (layoutState.mLayoutDirection
                == LayoutState.LAYOUT_START)) {
            addView(view);
        } else {
            addView(view, 0);
        }
    } else {
        if (mShouldReverseLayout == (layoutState.mLayoutDirection
                == LayoutState.LAYOUT_START)) {
            addDisappearingView(view);
        } else {
            addDisappearingView(view, 0);
        }
    }
    measureChildWithMargins(view, 0, 0);
    result.mConsumed = mOrientationHelper.getDecoratedMeasurement(view);
    int left, top, right, bottom;
    if (mOrientation == VERTICAL) {
        if (isLayoutRTL()) {
            right = getWidth() - getPaddingRight();
            left = right - mOrientationHelper.getDecoratedMeasurementInOther(view);
        } else {
            left = getPaddingLeft();
            right = left + mOrientationHelper.getDecoratedMeasurementInOther(view);
        }
        if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
            bottom = layoutState.mOffset;
            top = layoutState.mOffset - result.mConsumed;
        } else {
            top = layoutState.mOffset;
            bottom = layoutState.mOffset + result.mConsumed;
        }
    } else {
        top = getPaddingTop();
        bottom = top + mOrientationHelper.getDecoratedMeasurementInOther(view);

        if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
            right = layoutState.mOffset;
            left = layoutState.mOffset - result.mConsumed;
        } else {
            left = layoutState.mOffset;
            right = layoutState.mOffset + result.mConsumed;
        }
    }
    // We calculate everything with View's bounding box (which includes decor and margins)
    // To calculate correct layout position, we subtract margins.
    layoutDecoratedWithMargins(view, left, top, right, bottom);
    if (DEBUG) {
        Log.d(TAG, "laid out child at position " + getPosition(view) + ", with l:"
                + (left + params.leftMargin) + ", t:" + (top + params.topMargin) + ", r:"
                + (right - params.rightMargin) + ", b:" + (bottom - params.bottomMargin));
    }
    // Consume the available space if the view is not removed OR changed
    if (params.isItemRemoved() || params.isItemChanged()) {
        result.mIgnoreConsumed = true;
    }
    result.mFocusable = view.hasFocusable();
}

如何复用的？就是addView(view)方法！利用addView(view)方法将Item添加进去。参数view就是：

 View view = layoutState.next(recycler);

看看next方法内部都干了啥：

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

调用了关键代码：

final View view = recycler.getViewForPosition(mCurrentPosition);

getViewForPosition(mCurrentPosition)方法会调用tryGetViewHolderForPositionByDeadline()方法：

@Nullable
ViewHolder tryGetViewHolderForPositionByDeadline(int position,
        boolean dryRun, long deadlineNs) {
    if (position < 0 || position >= mState.getItemCount()) {
        throw new IndexOutOfBoundsException("Invalid item position " + position
                + "(" + position + "). Item count:" + mState.getItemCount()
                + exceptionLabel());
    }
    boolean fromScrapOrHiddenOrCache = false;
    ViewHolder holder = null;
    // 0) 在布局之前
    if (mState.isPreLayout()) {
		//根据位置、id获取holder
        holder = getChangedScrapViewForPosition(position);
        fromScrapOrHiddenOrCache = holder != null;
    }
    // 1) 通过item的position获取holder
    if (holder == null) {
        holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
        if (holder != null) {
            if (!validateViewHolderForOffsetPosition(holder)) {
                // recycle holder (and unscrap if relevant) since it can't be used
                if (!dryRun) {
                    // we would like to recycle this but need to make sure it is not used by
                    // animation logic etc.
                    holder.addFlags(ViewHolder.FLAG_INVALID);
                    if (holder.isScrap()) {
                        removeDetachedView(holder.itemView, false);
                        holder.unScrap();
                    } else if (holder.wasReturnedFromScrap()) {
                        holder.clearReturnedFromScrapFlag();
                    }
                    recycleViewHolderInternal(holder);
                }
                holder = null;
            } else {
                fromScrapOrHiddenOrCache = true;
            }
        }
    }
    if (holder == null) {
        final int offsetPosition = mAdapterHelper.findPositionOffset(position);
        if (offsetPosition < 0 || offsetPosition >= mAdapter.getItemCount()) {
            throw new IndexOutOfBoundsException("Inconsistency detected. Invalid item "
                    + "position " + position + "(offset:" + offsetPosition + ")."
                    + "state:" + mState.getItemCount() + exceptionLabel());
        }

        final int type = mAdapter.getItemViewType(offsetPosition);
        // 2) 通过item的id找
        if (mAdapter.hasStableIds()) {
            holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
                    type, dryRun);
            if (holder != null) {
                // update position
                holder.mPosition = offsetPosition;
                fromScrapOrHiddenOrCache = true;
            }
        }
        if (holder == null && mViewCacheExtension != null) {
            // We are NOT sending the offsetPosition because LayoutManager does not
            // know it.
            final View view = mViewCacheExtension
                    .getViewForPositionAndType(this, position, type);
            if (view != null) {
                holder = getChildViewHolder(view);
                if (holder == null) {
                    throw new IllegalArgumentException("getViewForPositionAndType returned"
                            + " a view which does not have a ViewHolder"
                            + exceptionLabel());
                } else if (holder.shouldIgnore()) {
                    throw new IllegalArgumentException("getViewForPositionAndType returned"
                            + " a view that is ignored. You must call stopIgnoring before"
                            + " returning this view." + exceptionLabel());
                }
            }
        }
        if (holder == null) { // fallback to pool
            if (DEBUG) {
                Log.d(TAG, "tryGetViewHolderForPositionByDeadline("
                        + position + ") fetching from shared pool");
            }
            holder = getRecycledViewPool().getRecycledView(type);
            if (holder != null) {
                holder.resetInternal();
                if (FORCE_INVALIDATE_DISPLAY_LIST) {
                    invalidateDisplayListInt(holder);
                }
            }
        }
        if (holder == null) {
            long start = getNanoTime();
            if (deadlineNs != FOREVER_NS
                    && !mRecyclerPool.willCreateInTime(type, start, deadlineNs)) {
                // abort - we have a deadline we can't meet
                return null;
            }
            holder = mAdapter.createViewHolder(RecyclerView.this, type);
            if (ALLOW_THREAD_GAP_WORK) {
                // only bother finding nested RV if prefetching
                RecyclerView innerView = findNestedRecyclerView(holder.itemView);
                if (innerView != null) {
                    holder.mNestedRecyclerView = new WeakReference<>(innerView);
                }
            }

            long end = getNanoTime();
            mRecyclerPool.factorInCreateTime(type, end - start);
            if (DEBUG) {
                Log.d(TAG, "tryGetViewHolderForPositionByDeadline created new ViewHolder");
            }
        }
    }

    // This is very ugly but the only place we can grab this information
    // before the View is rebound and returned to the LayoutManager for post layout ops.
    // We don't need this in pre-layout since the VH is not updated by the LM.
    if (fromScrapOrHiddenOrCache && !mState.isPreLayout() && holder
            .hasAnyOfTheFlags(ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST)) {
        holder.setFlags(0, ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
        if (mState.mRunSimpleAnimations) {
            int changeFlags = ItemAnimator
                    .buildAdapterChangeFlagsForAnimations(holder);
            changeFlags |= ItemAnimator.FLAG_APPEARED_IN_PRE_LAYOUT;
            final ItemHolderInfo info = mItemAnimator.recordPreLayoutInformation(mState,
                    holder, changeFlags, holder.getUnmodifiedPayloads());
            recordAnimationInfoIfBouncedHiddenView(holder, info);
        }
    }

    boolean bound = false;
    if (mState.isPreLayout() && holder.isBound()) {
        // do not update unless we absolutely have to.
        holder.mPreLayoutPosition = position;
    } else if (!holder.isBound() || holder.needsUpdate() || holder.isInvalid()) {
        if (DEBUG && holder.isRemoved()) {
            throw new IllegalStateException("Removed holder should be bound and it should"
                    + " come here only in pre-layout. Holder: " + holder
                    + exceptionLabel());
        }
        final int offsetPosition = mAdapterHelper.findPositionOffset(position);
        bound = tryBindViewHolderByDeadline(holder, offsetPosition, position, deadlineNs);
    }

    final ViewGroup.LayoutParams lp = holder.itemView.getLayoutParams();
    final LayoutParams rvLayoutParams;
    if (lp == null) {
        rvLayoutParams = (LayoutParams) generateDefaultLayoutParams();
        holder.itemView.setLayoutParams(rvLayoutParams);
    } else if (!checkLayoutParams(lp)) {
        rvLayoutParams = (LayoutParams) generateLayoutParams(lp);
        holder.itemView.setLayoutParams(rvLayoutParams);
    } else {
        rvLayoutParams = (LayoutParams) lp;
    }
    rvLayoutParams.mViewHolder = holder;
    rvLayoutParams.mPendingInvalidate = fromScrapOrHiddenOrCache && bound;
    return holder;
}

1. getChangedScrapViewForPosition方法—>mChangedScrap

在布局之前，根据position、id来获取到holder。

ViewHolder getChangedScrapViewForPosition(int position) {
    // If pre-layout, check the changed scrap for an exact match.
    final int changedScrapSize;
    if (mChangedScrap == null || (changedScrapSize = mChangedScrap.size()) == 0) {
        return null;
    }
    // find by position
    for (int i = 0; i < changedScrapSize; i++) {
        final ViewHolder holder = mChangedScrap.get(i);
        if (!holder.wasReturnedFromScrap() && holder.getLayoutPosition() == position) {
            holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
            return holder;
        }
    }
    // find by id
    if (mAdapter.hasStableIds()) {
        final int offsetPosition = mAdapterHelper.findPositionOffset(position);
        if (offsetPosition > 0 && offsetPosition < mAdapter.getItemCount()) {
            final long id = mAdapter.getItemId(offsetPosition);
            for (int i = 0; i < changedScrapSize; i++) {
                final ViewHolder holder = mChangedScrap.get(i);
                if (!holder.wasReturnedFromScrap() && holder.getItemId() == id) {
                    holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
                    return holder;
                }
            }
        }
    }
    return null;
}

final ViewHolder holder = mChangedScrap.get(i);是一个ArrayList,说明复用的对象是ViewHolder。ViewHolder可以理解为放View的容器，RecyclerView的ItemView中有很多的View（如：ImageView、TextView等），这些View都是放在ViewHolder中的。

2.getScrapOrHiddenOrCachedHolderForPosition—>mAttachedScrap、mCachedViews

如果上一步拿到的holder ！=null，说明上一步的holder拿取成功，就不用去碎片、隐藏list、缓存中查找了。反之…

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

    // Try first for an exact, non-invalid match from scrap.
    for (int i = 0; i < scrapCount; i++) {
        final ViewHolder holder = mAttachedScrap.get(i);
        if (!holder.wasReturnedFromScrap() && holder.getLayoutPosition() == position
                && !holder.isInvalid() && (mState.mInPreLayout || !holder.isRemoved())) {
            holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
            return holder;
        }
    }

    if (!dryRun) {
        View view = mChildHelper.findHiddenNonRemovedView(position);
        if (view != null) {
            // This View is good to be used. We just need to unhide, detach and move to the
            // scrap list.
            final ViewHolder vh = getChildViewHolderInt(view);
            mChildHelper.unhide(view);
            int layoutIndex = mChildHelper.indexOfChild(view);
            if (layoutIndex == RecyclerView.NO_POSITION) {
                throw new IllegalStateException("layout index should not be -1 after "
                        + "unhiding a view:" + vh + exceptionLabel());
            }
            mChildHelper.detachViewFromParent(layoutIndex);
            scrapView(view);
            vh.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP
                    | ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
            return vh;
        }
    }

    // Search in our first-level recycled view cache.
    final int cacheSize = mCachedViews.size();
    for (int i = 0; i < cacheSize; i++) {
        final ViewHolder holder = mCachedViews.get(i);
        // invalid view holders may be in cache if adapter has stable ids as they can be
        // retrieved via getScrapOrCachedViewForId
        if (!holder.isInvalid() && holder.getLayoutPosition() == position) {
            if (!dryRun) {
                mCachedViews.remove(i);
            }
            if (DEBUG) {
                Log.d(TAG, "getScrapOrHiddenOrCachedHolderForPosition(" + position
                        + ") found match in cache: " + holder);
            }
            return holder;
        }
    }
    return null;
}

final ViewHolder holder = mAttachedScrap.get(i);这是一个ArrayList集合，这属于第一级缓存。
下面 还有 final ViewHolder holder = mCachedViews.get(i);也是一个ArrayList集合—>属于第二级缓存

3. getScrapOrCachedViewForId—>mAttachedScrap、mCachedViews

通过id,从废料/缓存中查找:

ViewHolder getScrapOrCachedViewForId(long id, int type, boolean dryRun) {
    // Look in our attached views first
    final int count = mAttachedScrap.size();
    for (int i = count - 1; i >= 0; i--) {
        final ViewHolder holder = mAttachedScrap.get(i);
        if (holder.getItemId() == id && !holder.wasReturnedFromScrap()) {
            if (type == holder.getItemViewType()) {
                holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
                if (holder.isRemoved()) {
                    // this might be valid in two cases:
                    // > item is removed but we are in pre-layout pass
                    // >> do nothing. return as is. make sure we don't rebind
                    // > item is removed then added to another position and we are in
                    // post layout.
                    // >> remove removed and invalid flags, add update flag to rebind
                    // because item was invisible to us and we don't know what happened in
                    // between.
                    if (!mState.isPreLayout()) {
                        holder.setFlags(ViewHolder.FLAG_UPDATE, ViewHolder.FLAG_UPDATE
                                | ViewHolder.FLAG_INVALID | ViewHolder.FLAG_REMOVED);
                    }
                }
                return holder;
            } else if (!dryRun) {
                // if we are running animations, it is actually better to keep it in scrap
                // but this would force layout manager to lay it out which would be bad.
                // Recycle this scrap. Type mismatch.
                mAttachedScrap.remove(i);
                removeDetachedView(holder.itemView, false);
                quickRecycleScrapView(holder.itemView);
            }
        }
    }

    // Search the first-level cache
    final int cacheSize = mCachedViews.size();
    for (int i = cacheSize - 1; i >= 0; i--) {
        final ViewHolder holder = mCachedViews.get(i);
        if (holder.getItemId() == id) {
            if (type == holder.getItemViewType()) {
                if (!dryRun) {
                    mCachedViews.remove(i);
                }
                return holder;
            } else if (!dryRun) {
                recycleCachedViewAt(i);
                return null;
            }
        }
    }
    return null;
}

查找顺序和上一步一样：
先从废料中查找：final ViewHolder holder = mAttachedScrap.get(i);
再去缓存中找：final ViewHolder holder = mCachedViews.get(i);

4.getViewForPositionAndType()—>mViewCacheExtension

这是自定义的复用机制，一般不会用到。

if (holder == null && mViewCacheExtension != null) {
    // We are NOT sending the offsetPosition because LayoutManager does not
    // know it.
    final View view = mViewCacheExtension
            .getViewForPositionAndType(this, position, type);
    if (view != null) {
        holder = getChildViewHolder(view);
        if (holder == null) {
            throw new IllegalArgumentException("getViewForPositionAndType returned"
                    + " a view which does not have a ViewHolder"
                    + exceptionLabel());
        } else if (holder.shouldIgnore()) {
            throw new IllegalArgumentException("getViewForPositionAndType returned"
                    + " a view that is ignored. You must call stopIgnoring before"
                    + " returning this view." + exceptionLabel());
        }
    }
}

5.getRecycledViewPool()缓存池机制—>Pool

public ViewHolder getRecycledView(int viewType) {
    final ScrapData scrapData = mScrap.get(viewType);
    if (scrapData != null && !scrapData.mScrapHeap.isEmpty()) {
        final ArrayList<ViewHolder> scrapHeap = scrapData.mScrapHeap;
        return scrapHeap.remove(scrapHeap.size() - 1);
    }
    return null;
}
static class ScrapData {
    ArrayList<ViewHolder> mScrapHeap = new ArrayList<>();
    int mMaxScrap = DEFAULT_MAX_SCRAP;
    long mCreateRunningAverageNs = 0;
    long mBindRunningAverageNs = 0;
}
SparseArray<ScrapData> mScrap = new SparseArray<>();

ViewType的作用：多布局 ，多种type的item布局。SparseArray和Map类似，K：viewType V：ScrapData
ScrapData内保存的就是ArrayList
首先通过ViewType拿到ScrapData，就相当于得到了ArrayList，然后就通过scrapHeap.remove方法得到对应的ViewHolder。
缓存池的默认大小：

private static final int DEFAULT_MAX_SCRAP = 5;

缓冲池
之所以remove而非get，是因为只要拿到了就得需要移除出缓存池。仔细看remove的是第几位？scrapHeap.size() - 1 即最后一位。所以缓存池的数据结构为栈，特点就是先进后出！

6.mAdapter.createViewHolder

如果经历了以上5步之后仍然没能找到holder，那就调用mAdapter的createViewHolder方法，间接调用的 onCreateViewHolder(parent, viewType)来创建一个ViewHolder。

public final VH createViewHolder(ViewGroup parent, int viewType) {
    TraceCompat.beginSection(TRACE_CREATE_VIEW_TAG);
    final VH holder = onCreateViewHolder(parent, viewType);
    holder.mItemViewType = viewType;
    TraceCompat.endSection();
    return holder;
}

这也就说明了，为何onCreateViewHolder有时不会被调用？因为要先经历4级缓存找VH，实在找不到才会调用onCreateViewHolder新建！

最后，bindViewHolder

回到tryGetViewHolderForPositionByDeadline方法，在经历了1~6步之后，就要开始bind了：

boolean bound = false;
if (mState.isPreLayout() && holder.isBound()) {
    // do not update unless we absolutely have to.
    holder.mPreLayoutPosition = position;
} else if (!holder.isBound() || holder.needsUpdate() || holder.isInvalid()) {
    if (DEBUG && holder.isRemoved()) {
        throw new IllegalStateException("Removed holder should be bound and it should"
                + " come here only in pre-layout. Holder: " + holder
                + exceptionLabel());
    }
    final int offsetPosition = mAdapterHelper.findPositionOffset(position);
    bound = tryBindViewHolderByDeadline(holder, offsetPosition, position, deadlineNs);
}

经过tryBindViewHolderByDeadline方法调用了

mAdapter.bindViewHolder(holder, offsetPosition);

public final void bindViewHolder(VH holder, int position) {
    holder.mPosition = position;
    if (hasStableIds()) {
        holder.mItemId = getItemId(position);
    }
    holder.setFlags(ViewHolder.FLAG_BOUND,
            ViewHolder.FLAG_BOUND | ViewHolder.FLAG_UPDATE | ViewHolder.FLAG_INVALID
                    | ViewHolder.FLAG_ADAPTER_POSITION_UNKNOWN);
    TraceCompat.beginSection(TRACE_BIND_VIEW_TAG);
    onBindViewHolder(holder, position, holder.getUnmodifiedPayloads());
    holder.clearPayload();
    final ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
    if (layoutParams instanceof RecyclerView.LayoutParams) {
        ((LayoutParams) layoutParams).mInsetsDirty = true;
    }
    TraceCompat.endSection();
}

至此，整个复用流程就结束了。

回收：recycleByLayoutState(recycler, layoutState)

回收流程
分上下两个方向的滚动：

private void recycleByLayoutState(RecyclerView.Recycler recycler, LayoutState layoutState) {
    if (!layoutState.mRecycle || layoutState.mInfinite) {
        return;
    }
    if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
        recycleViewsFromEnd(recycler, layoutState.mScrollingOffset);
    } else {
        recycleViewsFromStart(recycler, layoutState.mScrollingOffset);
    }
}

它俩都会层次调用recycleChildren()方法—> removeAndRecycleViewAt方法：

public void removeAndRecycleViewAt(int index, Recycler recycler) {
    final View view = getChildAt(index);
    removeViewAt(index);
    recycler.recycleView(view);
}

最终调用了终极回收方法recycler.recycleView(view)：

public void recycleView(View view) {
    // This public recycle method tries to make view recycle-able since layout manager
    // intended to recycle this view (e.g. even if it is in scrap or change cache)
    ViewHolder holder = getChildViewHolderInt(view);
    if (holder.isTmpDetached()) {
        removeDetachedView(view, false);
    }
    if (holder.isScrap()) {
        holder.unScrap();
    } else if (holder.wasReturnedFromScrap()) {
        holder.clearReturnedFromScrapFlag();
    }
    recycleViewHolderInternal(holder);
}

通过recycleViewHolderInternal(holder)方法来内部回收holder：

void recycleViewHolderInternal(ViewHolder holder) {
    if (holder.isScrap() || holder.itemView.getParent() != null) {
        throw new IllegalArgumentException(
                "Scrapped or attached views may not be recycled. isScrap:"
                        + holder.isScrap() + " isAttached:"
                        + (holder.itemView.getParent() != null) + exceptionLabel());
    }

    if (holder.isTmpDetached()) {
        throw new IllegalArgumentException("Tmp detached view should be removed "
                + "from RecyclerView before it can be recycled: " + holder
                + exceptionLabel());
    }

    if (holder.shouldIgnore()) {
        throw new IllegalArgumentException("Trying to recycle an ignored view holder. You"
                + " should first call stopIgnoringView(view) before calling recycle."
                + exceptionLabel());
    }
    //noinspection unchecked
    final boolean transientStatePreventsRecycling = holder
            .doesTransientStatePreventRecycling();
    final boolean forceRecycle = mAdapter != null
            && transientStatePreventsRecycling
            && mAdapter.onFailedToRecycleView(holder);
    boolean cached = false;
    boolean recycled = false;
    if (DEBUG && mCachedViews.contains(holder)) {
        throw new IllegalArgumentException("cached view received recycle internal? "
                + holder + exceptionLabel());
    }
    if (forceRecycle || holder.isRecyclable()) {
        if (mViewCacheMax > 0
                && !holder.hasAnyOfTheFlags(ViewHolder.FLAG_INVALID
                | ViewHolder.FLAG_REMOVED
                | ViewHolder.FLAG_UPDATE
                | ViewHolder.FLAG_ADAPTER_POSITION_UNKNOWN)) {
            // mViewCacheMax默认大小为2
            int cachedViewSize = mCachedViews.size();
            if (cachedViewSize >= mViewCacheMax && cachedViewSize > 0) {
                recycleCachedViewAt(0);
                cachedViewSize--;
            }

            int targetCacheIndex = cachedViewSize;
            if (ALLOW_THREAD_GAP_WORK
                    && cachedViewSize > 0
                    && !mPrefetchRegistry.lastPrefetchIncludedPosition(holder.mPosition)) {
                // when adding the view, skip past most recently prefetched views
                int cacheIndex = cachedViewSize - 1;
                while (cacheIndex >= 0) {
                    int cachedPos = mCachedViews.get(cacheIndex).mPosition;
                    if (!mPrefetchRegistry.lastPrefetchIncludedPosition(cachedPos)) {
                        break;
                    }
                    cacheIndex--;
                }
                targetCacheIndex = cacheIndex + 1;
            }
            mCachedViews.add(targetCacheIndex, holder);
            cached = true;
        }
        if (!cached) {
            addViewHolderToRecycledViewPool(holder, true);
            recycled = true;
        }
    } else {
        // NOTE: A view can fail to be recycled when it is scrolled off while an animation
        // runs. In this case, the item is eventually recycled by
        // ItemAnimatorRestoreListener#onAnimationFinished.

        // TODO: consider cancelling an animation when an item is removed scrollBy,
        // to return it to the pool faster
        if (DEBUG) {
            Log.d(TAG, "trying to recycle a non-recycleable holder. Hopefully, it will "
                    + "re-visit here. We are still removing it from animation lists"
                    + exceptionLabel());
        }
    }
    // even if the holder is not removed, we still call this method so that it is removed
    // from view holder lists.
    mViewInfoStore.removeViewHolder(holder);
    if (!cached && !recycled && transientStatePreventsRecycling) {
        holder.mOwnerRecyclerView = null;
    }
}

我们看mCachedViews.size()的默认大小为2。
在这里插入图片描述
回收机制，就是将页面中的Item缓存到数据结构中。判断满没满，如果没满，就：

mCachedViews.add(targetCacheIndex, holder);

如果满了，就：

recycleCachedViewAt(0);
cachedViewSize--;

首先从mCachedViews中拿出一个position为0的ViewHolder，即第一个。这样，position=1位置的ViewHolder就变成了position=0。

void recycleCachedViewAt(int cachedViewIndex) {
    if (DEBUG) {
        Log.d(TAG, "Recycling cached view at index " + cachedViewIndex);
    }
    ViewHolder viewHolder = mCachedViews.get(cachedViewIndex);
    if (DEBUG) {
        Log.d(TAG, "CachedViewHolder to be recycled: " + viewHolder);
    }
    addViewHolderToRecycledViewPool(viewHolder, true);
    mCachedViews.remove(cachedViewIndex);
}

然后将其添加到缓存池中去：

void addViewHolderToRecycledViewPool(ViewHolder holder, boolean dispatchRecycled) {
    clearNestedRecyclerViewIfNotNested(holder);
    if (holder.hasAnyOfTheFlags(ViewHolder.FLAG_SET_A11Y_ITEM_DELEGATE)) {
        holder.setFlags(0, ViewHolder.FLAG_SET_A11Y_ITEM_DELEGATE);
        ViewCompat.setAccessibilityDelegate(holder.itemView, null);
    }
    if (dispatchRecycled) {
        dispatchViewRecycled(holder);
    }
    holder.mOwnerRecyclerView = null;
    getRecycledViewPool().putRecycledView(holder);
}

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);
}

先拿到ArrayList scrapHeap集合，判断如果缓存池Pool的ViewType为0的位置的Value：ArrayList
已经存满了，那吗就直接将mCachedViews中取出的第一个，直接丢弃（return）。为啥不是替换呢？
因为scrap.resetInternal();会将ViewHolder中的数据、状态等直接清空。好比一个玻璃杯，装满了一杯水。如果提着一个水壶过来，
继续加水，拿根本没必要。除非水壶里装的是“肥宅快乐水”，我才会把杯子里的水倒掉再重新装。
为啥mCachedViews必须先进先出？因为position=0和position=1存放的内容不同。

总的来说，recycleCachedViewAt方法做了3件事：

  • ①ViewHolder viewHolder = mCachedViews.get(cachedViewIndex);把位置index=0的拿出来，这样位置index=1就自然成了index=0。换句话说，mCachedViews就是先进先出
  • ②addViewHolderToRecycledViewPool(viewHolder,true)—>getRecycledViewPool().putRecycledView(holder)添加到缓存池中去
  • ③mCachedViews.remove(cachedViewIndex)将其移除出去

至此，回收机制就结束了。

结合mCachedViews和缓冲池Pool，整个流程如下：
在这里插入图片描述

墨玉浮白
关注
专栏目录
深入RecyclerView学习—缓存机制
2401_84149765的博客
04-21 444
/ 缓存池// 自定义缓存// 对应mCachedViews默认大小上面的代码也很容易看到RecyclerView缓存的位置，这里大概可以分为4种类别：Scrap缓存：对应当前已加载的视图，也就是屏幕中的视图；Cache缓存：刚刚移出屏幕的Item，默认大小是2个。缓存中的Item匹配后可以直接展示。根据FIFO原则先把老的数据放入下一级缓存中（比如：RecycledViewPool），然后添加新数据；ViewCacheExtension缓存：用来给开发者自定义的缓存。
RecyclerView的缓存机制
shiningdreamercaihua的博客
01-06 3048
RecyclerView的缓存机制 RecyclerView缓存机制（咋复用？） 真正带你搞懂 RecyclerView 的缓存机制，再也不怕面试被虐了！ 看完这篇，面试RecyclerView的时候再也不怕了 ...
RecyclerView的缓存机制（面试常客）
最新发布
qq_44016573的博客
08-14 1223
在构建滚动列表时，我们常首选RecyclerView，出于它优秀的缓存复用机制。
RecyclerView缓存机制
devallever的博客
03-20 209
缓存层级(缓存结构/缓存类型) ScrapView(脏视图)： 布局期间进入临时分离状态的子视图 可以重复使用，而不会与父级RecyclerView完全分离，如果不需要重新绑定，则不进行修改如果视图被视为脏，则由适配器修改。 RV展示成功后，Scrap这层的缓存就为空了，在从Scrap中取视图的同时就被移出了缓存 这里的脏怎么理解呢？就是指那些在展示之前必须重新绑定的视图，比如一个视图...
RecyclerView缓存机制浅析
woqi0025的博客
02-19 583
RecyclerView缓存机制浅析 ​ RecyclerView在Android的应用上可以说已经取代了listview，其灵活，组装式设置，多缓存机制可以适应多列表在Android开发中各种各样的需求。 ​ 对于RecyclerView的缓存机制一直都想稍微的屡下思路，简单点说RecyclerView对比listview缓存机制中就是多了两层缓存的支持，listview是两级缓存，Recycl...
RecyclerView缓存、复用、回收机制源码解析
weixin_43700867的博客
08-29 495
RecyclerView缓存、复用、回收机制
RecyclerView缓存机制分析--GridlayoutManager中的坑
02-15 3152
前言 主要是接上一篇文章，想跟进下RecyclerView的源码，视图从源码层面找到解决RecyclerView+GridLayoutManager组合导致的滑动卡顿问题。 RecycleView在滑动的过程中，需要不断的创建、绑定item、绘制item，这里就不得不了解下recycleView的缓存机制。 缓存机制 其实关于recycleView的缓存机制，网上有很多相关文章：下面推荐几篇我自己...
【腾讯Bugly干货分享】Android ListView与RecyclerView对比浅析--缓存机制
腾讯Bugly的专栏
10-31 9110
秉承着实事求是的作风，弄清楚RecyclerView是否有足够的吸引力替换掉ListView，我从性能这一角度出发，研究RecyclerView和ListView二者的缓存机制，并得到了一些较有益的"结论"，待我慢慢道来。 同时也希望能通过本文，让大家快速了解RecyclerView与ListView在缓存机制上的一些区别，在使用上也更加得心应手吧。
RecyclerView缓存及其原理
m0_46268254的博客
06-25 581
recyclerView四级缓存
RecyclerView(二) — 缓存机制分析
Elson的博客
10-26 2146
本文主要介绍了 RecyclerView 缓存机制实现原理。
6.RecyclerView缓存机制
汤坤
05-15 542
如果没有添加到这两个缓存集合中去,就将。内部类就是用来做缓存和复用的,里面包含了。如果从缓存和缓存池中都没有取到。缓存集合中第一个元素取出添加到缓存池。中去分析缓存和复用,也可以从。缓存集合中第一个元素移除.作为切入点,去分析我们的。相当于是列表中的一个。中去分析缓存和复用.
RecyclerView缓存原理，有图有真相
weixin_33739541的博客
08-19 651
1. RecyclerView缓存机制与性能优化关系 RecyclerView做性能优化要说复杂也复杂，比如说布局优化，缓存，预加载等等。其优化的点很多，在这些看似独立的点之间，其实存在一个枢纽：Adapter。因为所有的ViewHolder的创建和内容的绑定都需要经过Adaper的两个函数onCreateViewHolder和onBindViewHolder。 因此我们性能优化的本质就是要减少这...
【Android】RecyclerView的缓存机制
sinat_36955332的博客
11-25 324
1.缓存层级 Scrap (view)：在布局期间进入临时分离状态的子视图。废弃视图可以重复使用，而不会与父级RecyclerView完全分离，如果不需要重新绑定，则不进行修改，如果视图被视为脏，则由适配器修改。（这里的脏怎么理解呢？就是指那些在展示之前必须重新绑定的视图，比如一个视图原来展示的是“张三”，之后需要展示“李四”了，那么这个视图就是脏视图，需要重新绑定数据后再展示的。） Recycle (view):先前用于显示适配器特定位置的数据的视图可以放置在高速缓存中以供稍后重用再次显示相同类型的数据。
RecyclerView（三）—— RecyclerView的缓存机制
xingyu19911016的博客
11-22 3485
Recyclerview的缓存机制 recycler [ri:'saiklə] 反复循环器，[化工] 再循环器 Android新增的Recyclerview主要用于代替ListView。Recyclerview可扩展性强。 可以通过LayoutManager形成线性（横向与竖向）、网格、瀑布流布局。 通过OnItemTouchListener监听Item的事件，虽然比ListView.OnItemClickListener麻烦了点，但是可以实现更复杂的功能，比如item滑动。 提供了notifyItemI
RecycleView的缓存机制
weixin_38282516的博客
07-26 327
1.Scrape View 2.Recycle View
RecyclerView缓存机制深度解析与优化策略
"RecylerView的四级缓存分享_1211.pdf" 主题聚焦于Android平台上的RecyclerView组件，特别是其...以上就是关于RecyclerView的缓存机制、绘制原理以及相关问题的详细解析，希望能帮助你深入理解这个重要的Android组件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值