源碼的世界及其復(fù)雜，要是每一步都去深究，很容易迷失在里面歧寺，這里將RecyclerView的緩存機制抽出來重點分析燥狰，結(jié)合圖文的方式，希望可以給您帶來幫助斜筐！
RecyclerView的緩存機制猶如一個強大的引擎龙致，為RecyclerView的暢滑運行提供了強有力的保障；Android的大部分視圖都是列表形式的顷链，那么RecyclerView的出現(xiàn)無疑大大的提升了開發(fā)效率目代；那么RecyclerView的緩存究竟是如何工作的呢，那就讓我們來揭開謎底吧嗤练！
RecyclerView的緩存機制就是依附于Recycler這個類來實現(xiàn)的榛了，讓我們先來看一下這個類的成員變量：
public final class Recycler {
final ArrayList<ViewHolder> mAttachedScrap = new ArrayList<>();
ArrayList<ViewHolder> mChangedScrap = null;
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;
}
Recycler分析：
Recycler的成員變量總共有五個集合，分為兩部分煞抬，具體請看下面介紹霜大；
1，Scrap部分：
（1）mAttachedScrap：存儲的是當(dāng)前還在屏幕中的ViewHolder革答；
（2）mChangedScrap：存儲的是數(shù)據(jù)被更新的ViewHolder,比如說調(diào)用了Adapter的notifyItemChanged方法战坤；
2，Cache部分：
（1）mCachedViews：默認(rèn)大小為2残拐，通常用來存儲預(yù)取的ViewHolder途茫，同時在回收ViewHolder時，也會可能存儲一部分的ViewHolder溪食，這部分的ViewHolder通常來說囊卜，意義跟一級緩存差不多；
（2）mRecyclerPool：根據(jù)ViewType來緩存ViewHolder眠菇，每個ViewType的數(shù)組大小為5边败，可以動態(tài)的改變；
（3）mViewCacheExtension：自定義緩存捎废；
RecyclerView總共有4級緩存：
第一級緩存：Scrap部分笑窜；
第二級緩存：mCachedViews；
第三級緩存：mViewCacheExtension登疗；
第四級緩存：mRecyclerPool排截；
那么具體是怎么實現(xiàn)的呢，讓我們根據(jù)源碼來分析吧辐益；
首頁我們先看看ViewHolder的獲取流程断傲；
2，具體流程分析：
1智政，ViewHolder獲取流程：
首先先看流程圖：
看完流程圖认罩，那么接下來具體分析一下源碼是怎么操作的；
我在上一篇博客里面分析了RecyclerView的繪制流程续捂，里面提到了獲取ViewHolder 的方法垦垂，也就是layoutChunk方法里面的next(recycler)宦搬，讓我們看一下源碼里面寫了啥？
View next(RecyclerView.Recycler recycler) {
if (mScrapList != null) {
return nextViewFromScrapList();
}
final View view = recycler.getViewForPosition(mCurrentPosition);
mCurrentPosition += mItemDirection;
return view;
}
這里最終調(diào)用的是tryGetViewHolderForPositionByDeadline();
繼續(xù)分析tryGetViewHolderForPositionByDeadline()方法：
ViewHolder tryGetViewHolderForPositionByDeadline(int position,
boolean dryRun, long deadlineNs) {
// 第一步
if (mState.isPreLayout()) {
holder = getChangedScrapViewForPosition(position);
fromScrapOrHiddenOrCache = holder != null;
}
// 第二步
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
...
recycleViewHolderInternal(holder);
}
holder = null;
} else {
fromScrapOrHiddenOrCache = true;
}
}
}
if (holder == null) {
...
// 第三步
if (mAdapter.hasStableIds()) {
holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
type, dryRun);
...
}
// 第四步
if (holder == null && mViewCacheExtension != null) {
...
final View view = mViewCacheExtension
.getViewForPositionAndType(this, position, type);
if (view != null) {
holder = getChildViewHolder(view);
..
}
...
}
// 第五步
if (holder == null) { // fallback to pool
...
holder = getRecycledViewPool().getRecycledView(type);
...
}
// 第六步
if (holder == null) {
...
holder = mAdapter.createViewHolder(RecyclerView.this, type);
}
...
return holder;
}
（1）第一步：
首先劫拗，先判斷是否是預(yù)布局间校，也就是dispatchLayoutStep1()，這個方法在上一篇博客也已經(jīng)分析過了页慷，具體可以點擊查看憔足；
判斷如果是的話則從getChangedScrapViewForPosition()方法去獲取緩存的ViewHolder，
getChangedScrapViewForPosition()方法分析：
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;
}
這里做的操作就是從mChangedScrap里通過ItemID來獲取緩存的ViewHolder酒繁；
并給這個ViewHolder添加標(biāo)記位（ViewHolder.FLAG_RETURNED_FROM_SCRAP）滓彰，表示是從Scrap這個緩存里面獲取的；
（2）第二步：
第二步通過getScrapOrHiddenOrCachedHolderForPosition()方法來獲取緩存欲逃，讓我們看源碼繼續(xù)分析：
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;
}
通過上面源碼分析找蜜，這里是通過position先從mChangedScrap這個集合里面取緩存，如果取得到則給這個ViewHolder添加標(biāo)記位（ViewHolder.FLAG_RETURNED_FROM_SCRAP）稳析，表示是從Scrap這個緩存里面獲取的洗做；mChildHelper里的mHiddenViews是與動畫相關(guān)的緩存獲取，這里就不進行分析了彰居；那么如果從mChangedScrap獲取不到ViewHolder诚纸，下面就會從mCachedViews里面獲取緩存；
validateViewHolderForOffsetPosition()這個方法是用來判斷ViewHoler是否有效陈惰，如果無效了畦徘，則進行回收，具體操作在recycleViewHolderInternal(holder)這個方法里抬闯，后面會進行詳細(xì)分析井辆；
（3）第三步：
if (mAdapter.hasStableIds()) {
holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
type, dryRun);
if (holder != null) {
// update position
holder.mPosition = offsetPosition;
fromScrapOrHiddenOrCache = true;
}
}
這里通過判斷hasStableIds是否為true，如果為true則通過getScrapOrCachedViewForId()方法來獲取緩存溶握，這里是先從mChangedScrap里獲取緩存杯缺，如果獲取不到則從mCachedViews里面獲取緩存；和第二步類似這里就不過多分析了睡榆；
（4）第四步：
這一步通過mViewCacheExtension來獲取緩存萍肆，這個是自定義緩存，用到場景較少胀屿，也不過多分析了塘揣；
public abstract View getViewForPositionAndType(@NonNull Recycler recycler, int position,
int type);
這里是抽象方法，具體獲取邏輯由子類實現(xiàn)宿崭；
（5）第五步：
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;
}
這里是通過RecycledViewPool里的getRecycledView方法來獲取緩存亲铡，這里的mScrap是Android自定義的集合SparseArray，和map一樣，只是效率會更高效一些奖蔓；這里通過mScrap獲取scrapHeap的集合琅摩，然后獲取該集合的最后一個元素；
（6）第六步：
public final VH createViewHolder(@NonNull ViewGroup parent, int viewType) {
try {
TraceCompat.beginSection(TRACE_CREATE_VIEW_TAG);
final VH holder = onCreateViewHolder(parent, viewType);
if (holder.itemView.getParent() != null) {
throw new IllegalStateException("ViewHolder views must not be attached when"
+ " created. Ensure that you are not passing 'true' to the attachToRoot"
+ " parameter of LayoutInflater.inflate(..., boolean attachToRoot)");
}
holder.mItemViewType = viewType;
return holder;
} finally {
TraceCompat.endSection();
}
}
當(dāng)上面的幾步都獲取不到ViewHolder時锭硼，則通過調(diào)用Adapter的onCreateViewHolder()方法來創(chuàng)建一個ViewHolder并返回給RecyclerView；
那么到這里ViewHolder的獲取就分析完畢了蜕劝；
2檀头，ViewHolder的回收流程：
先來看一張詳細(xì)的流程圖：
這里把復(fù)雜的源碼通過流程圖展示出來，源碼的細(xì)節(jié)就不過多的描述了岖沛；
從上面的流程圖可以看出暑始，RecyclerView在滑動時候就會進行ViewHolder的回收，而具體的回收邏輯是在recycleViewHolderInternal()這個方法里婴削，我們重點分析這個方法廊镜；
先來看一下源碼：
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;
if (ALLOW_THREAD_GAP_WORK
&& cachedViewSize > 0
&& !mPrefetchRegistry.lastPrefetchIncludedPosition(holder.mPosition)) {
...
//第二步
mCachedViews.add(targetCacheIndex, holder);
cached = true;
}
if (!cached) {
//第三步
addViewHolderToRecycledViewPool(holder, true);
recycled = true;
}
} else {
...
}
...
}
這里主要做了三步操作：
1，第一步：
這里通過判斷mCachedViews的大小是否已經(jīng)超過最大唉俗，是的話則移除mCachedViews的第一個元素嗤朴，并添加到RecycledViewPool里面去；
具體請看下面源碼：
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);
}
2虫溜，第二步：
這里做的操作就是將ViewHolder緩存到mCachedViews集合里面去雹姊；
3，第三步：
這里通過判斷前面如果沒有將ViewHolder緩存到mCachedViews時衡楞，則把該mCachedViews緩存到RecycledViewPool里去吱雏，最終走的是下面這個方法；
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);
}
需要注意的是瘾境，RecycledViewPool的viewType歧杏，一個viewType默認(rèn)對應(yīng)可以存5個ViewHolder的緩存；
static class ScrapData {
final ArrayList<ViewHolder> mScrapHeap = new ArrayList<>();
int mMaxScrap = DEFAULT_MAX_SCRAP; // 默認(rèn)5個緩存的大忻允亍犬绒；
long mCreateRunningAverageNs = 0;
long mBindRunningAverageNs = 0;
}
當(dāng)然這個值是可以修改的，通過setMaxRecycledViews(int viewType, int max)這個方法來進行設(shè)置盒犹；
然后到這里你會發(fā)現(xiàn)懂更，這里只用了mCachedViews和RecycledViewPool來做緩存，上面提到的Scrap部分和ViewCacheExtension部分呢急膀？別急沮协，后面我們繼續(xù)來分析這兩者是什么時候用到的；
1卓嫂，Scrap部分
先來看一下Scrap部分慷暂，Scrap集合添加ViewHolder的方法主要是在scrapView()這個方法里面，而這個方法被getScrapOrHiddenOrCachedHolderForPosition()和scrapOrRecycleView()這個方法所調(diào)用；
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);
}
}
1行瑞，先來看一下這個getScrapOrHiddenOrCachedHolderForPosition()方法奸腺，這個方法的調(diào)用時機上面已經(jīng)提到過了，就是在獲取ViewHolder的時候血久，這里就不重復(fù)了突照；
那么我們再來看一下這個方法里面的這個scrap部分做了什么？
ViewHolder getScrapOrHiddenOrCachedHolderForPosition(int position, boolean dryRun) {
...
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;
}
}
...
return null;
}
這里通過mChildHelper的findHiddenNonRemovedView()方法來獲取一個ViewHolder氧吐，是從mHiddenViews這個集合里面獲取讹蘑，而這個mHiddenViews集合里面是存儲的和動畫相關(guān)的ViewHolder；
這里獲取了ViewHolder之后就通過scrapView()方法存儲到scrap里面去筑舅；
2座慰，接下來分析這個scrapOrRecycleView()方法的調(diào)用時機；
這個方法是由detachAndScrapAttachedViews()這個方法來調(diào)用的翠拣，而調(diào)用detachAndScrapAttachedViews()這個方法的地方是LayoutManager里的onLayoutChildren()方法版仔，也就是說，這里的回收是通過觸發(fā)LayoutManager的布局來調(diào)用的误墓；
這里最終回收的是通過mChildHelper.getChildAt(index)獲取的ViewHolder;
到這里蛮粮，scrap部分的回收就將完了；
2谜慌，ViewCacheExtension部分
接下來分析一下ViewCacheExtension部分的回收蝉揍，ViewCacheExtension這個自定義緩存的部分，在源碼里面只有取ViewHolder的邏輯畦娄，但是沒有存ViewHolder的邏輯又沾，看來谷歌是把ViewCacheExtension回收的邏輯交給開發(fā)者自己去實現(xiàn)了，那么這里就不過多的分析了熙卡；
那么到這里RecyclerView的緩存機制就分析完了杖刷；
