当前位置：网站首页 > 热门文章 > 正文

百度一面之RecyclerView的四级缓存详解

bigegpt 2024-10-22 10:04 8 浏览

本文通过在字节面试遇到的问题总结而出，如有不对地方，请及时批评指正。篇幅较长，请耐心阅读。

简介

RecyclerView作为Android开发广泛使用的框架之一，它的出现取代了ListView，支持多种布局样式，功能强大。如下图所示：

使用步骤

添加RecyclerView布局控件

定义适配器GridAdapter继承RecyclerView.Adapter抽象类

RecyclerView设置适配器

缓存详解

RecyclerView拥有高效的四级缓存：分别是屏幕内缓存（mChangeScrap），屏幕外缓存（mCacheViews），自定义缓存（mViewCacheExtension），缓存池（RecycledViewPool ）。

RecyclerView的缓存都是从滑动事件开始。

缓存过程

1 .RecyclerView->onTouchEvent()。

 public boolean onTouchEvent(MotionEvent e) {
       ......省略部分代码.......

       //获取当前RecyclerView的滑动方向
        final boolean canScrollHorizontally = mLayout.canScrollHorizontally();
        final boolean canScrollVertically = mLayout.canScrollVertically();
       ......省略部分代码.......
        switch (action) {
            case MotionEvent.ACTION_DOWN: {
                mScrollPointerId = e.getPointerId(0);
                //记录手指按下点的值
                mInitialTouchX = mLastTouchX = (int) (e.getX() + 0.5f);
                mInitialTouchY = mLastTouchY = (int) (e.getY() + 0.5f);
                int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
              ......省略部分代码.......
                startNestedScroll(nestedScrollAxis, TYPE_TOUCH);
            } break;

            case MotionEvent.ACTION_POINTER_DOWN: {
                mScrollPointerId = e.getPointerId(actionIndex);
                //记录手指按下点的值
                mInitialTouchX = mLastTouchX = (int) (e.getX(actionIndex) + 0.5f);
                mInitialTouchY = mLastTouchY = (int) (e.getY(actionIndex) + 0.5f);
            } break;

            case MotionEvent.ACTION_MOVE: {
                //获取当前屏幕的手指触摸点个数
                final int index = e.findPointerIndex(mScrollPointerId);
               //记录滑动值
                final int x = (int) (e.getX(index) + 0.5f);
                final int y = (int) (e.getY(index) + 0.5f);
                int dx = mLastTouchX - x;
                int dy = mLastTouchY - y;
                
                 ......省略部分代码.......

                if (mScrollState == SCROLL_STATE_DRAGGING) {
                    mReusableIntPair[0] = 0;
                    mReusableIntPair[1] = 0;
                    if (dispatchNestedPreScroll(
                            canScrollHorizontally ? dx : 0,
                            canScrollVertically ? dy : 0,
                            mReusableIntPair, mScrollOffset, TYPE_TOUCH
                    )) {
                        dx -= mReusableIntPair[0];
                        dy -= mReusableIntPair[1];
                        // 更新滑动偏移量
                        mNestedOffsets[0] += mScrollOffset[0];
                        mNestedOffsets[1] += mScrollOffset[1];
                        // 设置禁止父view拦截触摸事件
                        getParent().requestDisallowInterceptTouchEvent(true);
                    }

                    mLastTouchX = x - mScrollOffset[0];
                    mLastTouchY = y - mScrollOffset[1];
                    //滑动判断->缓存入口！！！
                    if (scrollByInternal(
                            canScrollHorizontally ? dx : 0,
                            canScrollVertically ? dy : 0,
                            e)) {
                           // 设置禁止父view拦截触摸事件
                        getParent().requestDisallowInterceptTouchEvent(true);
                    }
                    if (mGapWorker != null && (dx != 0 || dy != 0)) {
                        mGapWorker.postFromTraversal(this, dx, dy);
                    }
                }
            } break;

            case MotionEvent.ACTION_POINTER_UP: {
                onPointerUp(e);
            } break;

            case MotionEvent.ACTION_UP: {
                ........省略部分代码.........
                //重置滑动操作
                resetScroll();
            } break;

            case MotionEvent.ACTION_CANCEL: {
                //取消滑动
                cancelScroll();
            } break;
        }

        if (!eventAddedToVelocityTracker) {
            mVelocityTracker.addMovement(vtev);
        }
        vtev.recycle();

        return true;
    }

在onTouchEvent事件中处理RecyclerView的滑动事件进入到scrollByInternal( )方法。

2 .RecyclerView->onTouchEvent()->scrollByInternal( )

 boolean scrollByInternal(int x, int y, MotionEvent ev) {
        int unconsumedX = 0;
        int unconsumedY = 0;
        int consumedX = 0;
        int consumedY = 0;
   ........省略部分代码.........
         //判断适配器已经添加
        if (mAdapter != null) {
            mReusableIntPair[0] = 0;
            mReusableIntPair[1] = 0;
           //增量滑动 ->缓存入口！！！
           scrollStep(x, y, mReusableIntPair);
            consumedX = mReusableIntPair[0];
            consumedY = mReusableIntPair[1];
            unconsumedX = x - consumedX;
            unconsumedY = y - consumedY;
        }
     ........省略部分代码.........
         //滑动事件分发
        dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset,
                TYPE_TOUCH, mReusableIntPair);
        unconsumedX -= mReusableIntPair[0];
        unconsumedY -= mReusableIntPair[1];
        boolean consumedNestedScroll = mReusableIntPair[0] != 0 || mReusableIntPair[1] != 0;
      
        // 更新最后一次触摸偏移量
        mLastTouchX -= mScrollOffset[0];
        mLastTouchY -= mScrollOffset[1];
        mNestedOffsets[0] += mScrollOffset[0];
        mNestedOffsets[1] += mScrollOffset[1];
          ........省略部分代码.........
        return consumedNestedScroll || consumedX != 0 || consumedY != 0;
    }

scrollByInternal方法中记录手指在屏幕上的滑动偏移量，然后调用scrollStep()进行增量滑动RecyclerView。

3 .RecyclerView->onTouchEvent()->scrollByInternal( )->scrollStep()

void scrollStep(int dx, int dy, @Nullable int[] consumed) {
    //滑动期间禁止响应对requestLayout()的额外调用
    startInterceptRequestLayout();
    //记录滑动事件+1
    onEnterLayoutOrScroll();
    ........省略部分代码.........
    int consumedX = 0;
    int consumedY = 0;
    if (dx != 0) {
        //调用LinearLayoutManager的横向滑动->缓存入口！！！
        consumedX = mLayout.scrollHorizontallyBy(dx, mRecycler, mState);
    }
    if (dy != 0) {
          //调用LinearLayout的纵向滑动
        consumedY = mLayout.scrollVerticallyBy(dy, mRecycler, mState);
    }

     ........省略部分代码.........
    //退出滑动事件
    onExitLayoutOrScroll();
    //允许调用requestLayout()
    stopInterceptRequestLayout(false);

    if (consumed != null) {
        consumed[0] = consumedX;
        consumed[1] = consumedY;
    }
}

scrollStep()方法中通过调用mLayout.scrollHorizontallyBy()方法处理滑动事件，在RecyclerView使用中设置所有的LayoutManager都继承于LayoutManager这个抽象类，这里只分析LinearLayoutManager的方法即可。

4 .RecyclerView->onTouchEvent()->scrollByInternal( )->scrollStep()->LinearLayoutManager->scrollHorizontallyBy()。

public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler,
    RecyclerView.State state) {
    //校验滑动方向
    if (mOrientation == VERTICAL) {
        return 0;
    }
    return scrollBy(dx, recycler, state);
}

scrollHorizontallyBy()先校验滑动方向是否是水平方向，然后调用scrollBy()方法。

5 .RecyclerView->onTouchEvent()->scrollByInternal( )->scrollStep()->LinearLayoutManager->scrollHorizontallyBy()->scrollBy( )。

 int scrollBy(int delta, RecyclerView.Recycler recycler, RecyclerView.State state) {
     //判断RecyclerView的View个数   
     if (getChildCount() == 0 || delta == 0) {
            return 0;
        }
        ensureLayoutState();
        mLayoutState.mRecycle = true;
        //布局方向
        final int layoutDirection = delta > 0 ? LayoutState.LAYOUT_END : LayoutState.LAYOUT_START;
        final int absDelta = Math.abs(delta);
        //更新布局状态
        updateLayoutState(layoutDirection, absDelta, true, state);
        //计算滑动偏移量
        final int consumed = mLayoutState.mScrollingOffset
                  //处理滑动偏移->缓存入口！！！
                + fill(recycler, mLayoutState, state, false);

         ........省略部分代码.........
        return scrolled;
    }

scrollBy()中调用fill()方法，计算滑动偏移量。

6 .RecyclerView->onTouchEvent()->scrollByInternal( )->scrollStep()->LinearLayoutManager->scrollHorizontallyBy()->scrollBy( ）->fill( )

int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
            RecyclerView.State state, boolean stopOnFocusable) {
        // 记录开始偏移量
        final int start = layoutState.mAvailable;
        if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {
            // 异常处理
            if (layoutState.mAvailable < 0) {
                layoutState.mScrollingOffset += layoutState.mAvailable;
            }
            recycleByLayoutState(recycler, layoutState);
        }
        //滑动偏移量
        int remainingSpace = layoutState.mAvailable + layoutState.mExtraFillSpace;
        LayoutChunkResult layoutChunkResult = mLayoutChunkResult;
        while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {
            layoutChunkResult.resetInternal();
            //检查布局->缓存入口！！！
            layoutChunk(recycler, state, layoutState, layoutChunkResult);
            ........省略部分代码.........
        return start - layoutState.mAvailable;
    }

从fill()方法中的layoutChunk( )开始，才开始进入布局缓存的使用。

7 .RecyclerView->onTouchEvent()->scrollByInternal( )->scrollStep()->LinearLayoutManager->scrollHorizontallyBy()->scrollBy( ）->fill( )->layoutChunk（）

  void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
            LayoutState layoutState, LayoutChunkResult result) {
        //通过Recycler获取下一个即将显示的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;
        }
          ........省略部分代码.........
        result.mFocusable = view.hasFocusable();
    }
  View next(RecyclerView.Recycler recycler) {
            if (mScrapList != null) {
                return nextViewFromScrapList();
            }
            final View view = recycler.getViewForPosition(mCurrentPosition);
            mCurrentPosition += mItemDirection;
            return view;
        }
   public View getViewForPosition(int position) {
            return getViewForPosition(position, false);
        }

     View getViewForPosition(int position, boolean dryRun) {
            return tryGetViewHolderForPositionByDeadline(position, dryRun, FOREVER_NS).itemView;
 }

layoutChunk()中主要通过recycler获取下一个需要显示的View。

8 .RecyclerView->onTouchEvent()->scrollByInternal( )->scrollStep()->LinearLayoutManager->scrollHorizontallyBy()->scrollBy( ）->fill( )->layoutChunk（）->layoutState.next()->getViewForPosition()->tryGetViewHolderForPositionByDeadline()

ViewHolder tryGetViewHolderForPositionByDeadline(int position,
                                                 boolean dryRun, long deadlineNs) {
    //判断下一个需要显示的view的下标是否越界
    if (position < 0 || position >= mState.getItemCount()) {
        throw new IndexOutOfBoundsException("Invalid item position " + position
                                            + "(" + position + "). Item count:" + mState.getItemCount()
                                            + exceptionLabel());
    }
    //默认不从缓存中获取
    boolean fromScrapOrHiddenOrCache = false;
    //定义holder
    ViewHolder holder = null;
    // 1) 如果屏幕内有改变的scrap, 直接从scrap中获取
    if (mState.isPreLayout()) {
        holder = getChangedScrapViewForPosition(position);
        fromScrapOrHiddenOrCache = holder != null;
    }
    // 2)从/隐藏列表/缓存中按位置查找
    if (holder == null) {
        //先从屏幕内缓存查找(后面分析)
        holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
        if (holder != null) {
            if (!validateViewHolderForOffsetPosition(holder)) {
                // 如果不再使用了先回收
                if (!dryRun) {
                    //确保不再使用
                    //回收处理
                     ........省略部分代码.........
                }
                holder = null;
            } else {
                fromScrapOrHiddenOrCache = true;
            }
        }
    }
    if (holder == null) {
        //通过下一个view的位置获取偏移position
        final int offsetPosition = mAdapterHelper.findPositionOffset(position);
         ........省略部分代码.........
        final int type = mAdapter.getItemViewType(offsetPosition);
    
        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) {
            //从自定义缓存中查找，getViewForPositionAndType是个抽象方法，需要我们自己实现。
            final View view = mViewCacheExtension
        
                .getViewForPositionAndType(this, position, type);
            endingInvalidate = fromScrapOrHiddenOrCache && bound;
                    return holder;
                    }
         if (holder == null) { 
                    //从缓存池中查找。
                    holder = getRecycledViewPool().getRecycledView(type);
                    if (holder != null) {
                        holder.resetInternal();
                        if (FORCE_INVALIDATE_DISPLAY_LIST) {
                            invalidateDisplayListInt(holder);
                        }
                    }
                }

四级缓存

1 . getChangedScrapViewForPosition->从屏幕内缓存中查找

ViewHolder getChangedScrapViewForPosition(int position) {
 .............
// 先从屏幕内缓存查看可改变的holder
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;
    }
}
// 通过id从屏幕中查看holder
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;
}

2 .getScrapOrHiddenOrCachedHolderForPosition->先从屏幕内查找缓存，如果没有再从屏幕外查找缓存

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

    // 从屏幕内查找可复用的holder.mAttachedScrap最大长度为 5
    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;
        }
    }

    .....省略部分代码.....

    // 从屏幕外缓存中查找mCachedViews 最大长度为2
    final int cacheSize = mCachedViews.size();
    for (int i = 0; i < cacheSize; i++) {
        final ViewHolder holder = mCachedViews.get(i);
         
        if (!holder.isInvalid() && holder.getLayoutPosition() == position
            && !holder.isAttachedToTransitionOverlay()) {
            if (!dryRun) {
                //使用完从缓存中移除
                mCachedViews.remove(i);
            }
            .................
            return holder;
        }
    }
    return null;
}

3 .getViewForPositionAndType ->自定义缓存，需要自己实现

public abstract View getViewForPositionAndType(@NonNull Recycler recycler, int position,
                                               int type);

4 .getRecycledViewPool().getRecycledView(type)->从缓存池中获取缓存

public ViewHolder getRecycledView(int viewType) {
    //先根据布局类型获取ScrapData
    final ScrapData scrapData = mScrap.get(viewType);
if (scrapData != null && !scrapData.mScrapHeap.isEmpty()) {
    //再从ScrapData的mScrapHeap中查缓存holder，同时从缓存池中移除
    final ArrayList<ViewHolder> scrapHeap = scrapData.mScrapHeap; //最大长度为20
    for (int i = scrapHeap.size() - 1; i >= 0; i--) {
        if (!scrapHeap.get(i).isAttachedToTransitionOverlay()) {
            return scrapHeap.remove(i);
        }
    }
}
return null;
}

先从缓存池RecycledViewPool中根据布局类型获取对应的ViewHolder集合(最大长度为5),然后再从集合中查找缓存是否存在。

RecyclerViewPool类似于HashMap的数据结构，根据不同的布局类型viewType获取缓存Holder。

以上就是百度面试后总结的几个要点，还不会的同学赶紧学起来吧，感谢您的阅读，创造不易，如果您觉得本篇文章对您有帮助，请点击关注小编，您的支持就是小编创作的最大动力！

recyclerview横向滑动

上一篇：Android系统列表控件 android所有控件
下一篇：安卓RecyclerView使用技巧分享 android recyclerview使用

百度一面之RecyclerView的四级缓存详解

简介

使用步骤

缓存详解

缓存过程

四级缓存

相关推荐

idea本地配置连接远程hadoop集群的一些网络问题解决汇总

无缓存不行?例行升级的入门级阿斯加特AN2 SSD装机点评

Ceph运维手册(基于P版本)

大数据开发前要做什么准备?8台Hadoop服务器进行集群规划前配置

Tensorflow分类loss函数总结 tensorflow绘制loss曲线

R语言学习笔记(七) -离散型数据的模型预测2

iOS Runtime详解

PHP 远程调试最佳实践

7 个对 Java 意义重大的性能指标，你知道几个?

Laravel框架使用图片处理简单教程