码迷,mamicode.com
首页 > 移动开发 > 详细

Android源码解读——RecyclerView回收复用机制

时间:2021-01-04 11:29:05      阅读:0      评论:0      收藏:0      [点我收藏+]

标签:hold   binder   load()   四级   包括   containe   children   com   img   

问题归类:

  • 什么是回收?什么是复用?
  • 回收什么?复用什么?
  • 回收到哪里去?从哪里获得复用?
  • 什么时候回收?什么时候复用?

带着以上几个问题来分析源码,当以上问题都能解释清楚的时候,对RecyclerView回收复用机制的了解也算是完成了。

1、什么是回收?什么是复用?

回收:即缓存,RecyclerView的缓存是将内容存到集合里面。

复用:即取缓存,从集合中去获取。

2、回收什么?复用什么?

回收和复用的对象都是ViewHolder。

什么是ViewHolder?ViewHolder其实就是用来包装view的,我们可以将它看成列表的itemview

3、回收到哪里去?从哪里获得复用?

4、什么时候回收?什么时候复用?

问题3、4结合源码一起分析。

首先对RecyclerView进行普通的使用

 

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

    private Context context;
    private List<Star> starList;
    private static final String TAG = "TestRvAdapter";

    public TestRvAdapter(Context context, List<Star> starList) {
        this.context = context;
        this.starList = starList;
    }

    @NonNull
    @Override
    public TestRvAdapter.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(context).inflate(R.layout.rv_top_item, null);
        Log.e(TAG, "onCreateViewHolder: " + getItemCount());
        return new ViewHolder(view);
    }

    @Override
    public void onBindViewHolder(@NonNull TestRvAdapter.ViewHolder holder, int position) {
        holder.tv.setText(starList.get(position).getName());
        Log.e(TAG, "onBindViewHolder: " + position);
    }

    @Override
    public int getItemCount() {
        return starList == null ? 0 : starList.size();
    }

    public class ViewHolder extends RecyclerView.ViewHolder {
        private TextView tv;

        public ViewHolder(@NonNull View itemView) {
            super(itemView);
            tv = itemView.findViewById(R.id.tv_star);
        }
    }
}

 

public class RvTestActivity extends AppCompatActivity {
    private RecyclerView recyclerView;
    private List<Star> starList = new ArrayList<>();

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test_rv);

        initData();

        recyclerView = findViewById(R.id.test_rv);
        /*注意此处*/
        recyclerView.setLayoutManager(new GridLayoutManager(this, 1));
        recyclerView.addItemDecoration(new DividerItemDecoration(this, LinearLayout.VERTICAL));
        recyclerView.setAdapter(new TestRvAdapter(this, starList));

    }

    private void initData() {
        for (int i = 1; i <= 1000; i++) {
            starList.add(new Star(i + "", "快乐家族" + i));
        }
    }
}

以上代码相信都看得懂吧?我们看下代码细节。

在adapter的onCreateViewHolder和onBindViewHolder两个方法里面进行打印,然后在activity里面我们设置LayoutManager时,用的是GridLayoutManager,数量设置为1,其实跟LinearLayoutManager是一样的效果,但是这里为了方便测试,所以用的是GridLayoutManager,进入到GridLayoutManager源码也可以看到,他是继承自LinearLayoutManager的。 OK现在运行看看打印情况。

技术图片技术图片

可以发现,刚进入界面的时候,onCreateViewHolder和onBindViewHolder都进行了打印,而往下滑动之后只会打印onBindViewHolder,不会再进入onCreateViewHolder

我们把代码 new GridLayoutManager(this, 1) 的1改成8试试会是怎么样的打印情况:

 技术图片

可以看到,无论滚动到哪个item,onCreateViewHolder和onBindViewHolder都一直在打印,那么这是为什么呢?

接下来分析源码。

首先就 RecyclerView 的源码就有一万多行,这还没包括layoutmanager的,分析到底从何入手?那么我们知道,在触发onCreateViewHolder和onBindViewHolder的时候,我们都对屏幕进行了滑动,所以我们直接先进入 RecyclerView 的onTouchEvent看看RecyclerView 是如何进行滑动处理的。由于是滑动,因此我们直接进入action_move里面进行查看。(由于源码太多,就不贴上来了,源码流程只需要关系入口以及我们需要分析的部分就行了。)

入口:滑动 Move 事件 --> scrollByInternal --> scrollStep --> mLayout.scrollVerticallyBy(mLayout就是LayoutManager,所以我们要看他的实现类LinearLayoutManager.scrollVerticallyBy)  --> scrollBy --> fill --> layoutChunk --> layoutState.next获取view --> addView(view);

view就是从这里加载进RecyclerView 的,那么在addView之前有一个获取view的动作layoutState.next,我们具体分析一下到底是如何获取的。

layoutState.next --> getViewForPosition --> tryGetViewHolderForPositionByDeadline

tryGetViewHolderForPositionByDeadline就是我们最终需要找到的一个方法,在这个方法里面,RecyclerView 通过缓存取出viewHolder,我们可以看到里面有各种 if (holder == null) 的判断,那么到底是如何去取的呢?

分以下几种情况去获取ViewHolder

  1. getChangedScrapViewForPosition -- mChangeScrap 与动画相关
  2. getScrapOrHiddenOrCachedHolderForPosition -- mAttachedScrap 、mCachedViews
  3. getScrapOrCachedViewForId -- mAttachedScrap 、mCachedViews (ViewType,itemid)
  4. mViewCacheExtension.getViewForPositionAndType -- 自定义缓存
  5. getRecycledViewPool().getRecycledView -- 从缓冲池里面获取

 

归纳一下我们可以得出,RecyclerView 大致分为四级缓存

  • mChangeScrap与 mAttachedScrap,用来缓存还在屏幕内的 ViewHolder
  • mCachedViews,用来缓存移除屏幕之外的 ViewHolder
  • mViewCacheExtension,开发给用户的自定义扩展缓存,需要用户自己管理 View 的创建和缓存(通常用不到,至少目前为止我没用到过)
  • RecycledViewPool,ViewHolder 缓存池

多级缓存的最终目的就是为了提升性能

看到源码最后一个if语句,也就是当所有的缓存都没有viewHolder的时候,这个时候我们就需要创建,

holder = mAdapter.createViewHolder(RecyclerView.this, type);

createViewHolder方法里面自然的就调用到了adapter的onCreateViewHolder方法

也就是:当没有缓存的时候: mAdapter.createViewHolder --> onCreateViewHolder

    创建ViewHolder 后 绑定: tryBindViewHolderByDeadline--> mAdapter.bindViewHolder--> onBindViewHolder

以上为复用(取缓存)的过程,那么回收(存缓存)是个什么样的机制呢?

首先也是一样要找到入口

当我们刷新布局的时候,RecyclerView 会调用到 LinearLayoutManager 的 onLayoutChildren 方法。

LinearLayoutManager.onLayoutChildren --> detachAndScrapAttachedViews --> scrapOrRecycleView

    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()) {
                removeViewAt(index);
                recycler.recycleViewHolderInternal(viewHolder);
            } else {
                detachViewAt(index);
                recycler.scrapView(view);
                mRecyclerView.mViewInfoStore.onViewDetached(viewHolder);
            }
        }

 

那么在 scrapOrRecycleView 方法里面分为了两种情况:

  • recycler.recycleViewHolderInternal(viewHolder);
  • recycler.scrapView(view);

分析recycler.recycleViewHolderInternal(viewHolder);

进入到recycleViewHolderInternal方法,可以看到有如下的一个判断:

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

 

这段代码表示:如果ViewHolder不改变(有时候一个列表可能用到了多个ViewHolder),那么先判断mCachedViews的大小

         mCachedViews.size 大于默认可缓存的大小(默认为2),执行recycleCachedViewAt,实际上就是将cacheView里面的数据拿到RecycledViewPool缓存池里面,然后再把新的缓存存入到cacheView里面,采取的是先进先出的原则。

       缓存池里面保存的只是 ViewHolder 类型,没有数据,而cacheView是包含数据的(经过binder了的ViewHolder)。这也是为什么分级的原因,最终还是为了执行效率。

而缓冲池是与Map类似。他的缓存形式就如:ArrayList<ArrayList<viewholder>>, RecycledViewPool 会根据ViewType来进行分类,ArrayList<viewholder>对应的就是一个ViewType

我们进入recycleCachedViewAt--> addViewHolderToRecycledViewPool(缓存到缓存池里面)

如果上面的条件不满足,那么会执行到下面的if语句块,直接缓存到缓存池:

if (!cached) {
    addViewHolderToRecycledViewPool(holder, true);
    recycled = true;
}

 

直接执行addViewHolderToRecycledViewPool,可以看到与上面调用的方法一样,在这个方法里面会执行getRecycledViewPool().putRecycledView(holder)

 

 

    public void putRecycledView(ViewHolder scrap) {
            final int viewType = scrap.getItemViewType();
            final ArrayList<ViewHolder> scrapHeap = getScrapDataForType(viewType).mScrapHeap;
        //多余的直接丢弃 mMaxScrap = 5
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<viewholder>最多存储5个ViewHolder,多余的会直接丢弃不保存。

为什么数据满了之后,会直接丢弃呢?接着分析:

假如没有满的话,也就是没有多余的话,那么就会执行 scrap.resetInternal(); 

        void resetInternal() {
            mFlags = 0;
            mPosition = NO_POSITION;
            mOldPosition = NO_POSITION;
            mItemId = NO_ID;
            mPreLayoutPosition = NO_POSITION;
            mIsRecyclableCount = 0;
            mShadowedHolder = null;
            mShadowingHolder = null;
            clearPayload();
            mWasImportantForAccessibilityBeforeHidden = ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_AUTO;
            mPendingAccessibilityState = PENDING_ACCESSIBILITY_STATE_NOT_SET;
            clearNestedRecyclerViewIfNotNested(this);
        }        

 

这里面是将ViewHolder进行清空,然后再通过 scrapHeap.add(scrap); 进行保存,这也是为什么缓冲池里面只是 ViewHolder类型,而没有数据的原因,没有数据的话,我们缓存太多没有意义。

这也是为什么前面我们运行的时候,当值=8的时候,会不停的刷新onCreateViewHolder和onBindViewHolder,而为1的时候只刷新onBindViewHolder,因为其默认上限值为2+5=7,超过这个数,多余的就没进入缓存了。

以上分析完毕之后我们知道了,下面两种情况是如何缓存的了

技术图片

而第三种是系统不管的,也就是我们自定义的缓存

分析代码:recycler.scrapView(view),mAttachedScrap 和 mChangedScrap 这种情况

    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()) {
                    throw new IllegalArgumentException("Called scrap view with an invalid view."
                            + " Invalid views cannot be reused from scrap, they should rebound from"
                            + " recycler pool." + exceptionLabel());
                }
                holder.setScrapContainer(this, false);
                mAttachedScrap.add(holder);
            } else {
                if (mChangedScrap == null) {
                    mChangedScrap = new ArrayList<ViewHolder>();
                }
                holder.setScrapContainer(this, true);
                mChangedScrap.add(holder);
            }
        }

 

我们发现,该方法一进入的时候就直接在处理了 

mAttachedScrap.add(holder);
mChangedScrap.add(holder);

只是需要清楚上面的判断是如何判断的,其意思就是 if 的情况 ,当我们的标记没移除、或者失效、更新、动画不复用或者没动画的时候,就会利用 mAttachedScrap 进行保存,否则就用 mChangedScrap 进行保存。

完。

Android源码解读——RecyclerView回收复用机制

标签:hold   binder   load()   四级   包括   containe   children   com   img   

原文地址:https://www.cnblogs.com/lordjinsdream/p/14218075.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!