源碼的世界及其復雜，要是每一步都去深究，很容易迷失在里面，這里將RecyclerView的緩存機制抽出來重點分析，結合圖文的方式，希望可以給您帶來幫助！
RecyclerView的緩存機制猶如一個強大的引擎，為RecyclerView的暢滑運行提供了強有力的保障；Android的大部分視圖都是列表形式的，那么RecyclerView的出現無疑大大的提升了開發效率；那么RecyclerView的緩存究竟是如何工作的呢，那就讓我們來揭開謎底吧！
RecyclerView的緩存機制就是依附于Recycler這個類來實現的，讓我們先來看一下這個類的成員變量：
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：存儲的是當前還在屏幕中的ViewHolder；
（2）mChangedScrap：存儲的是數據被更新的ViewHolder,比如說調用了Adapter的notifyItemChanged方法；
2，Cache部分：
（1）mCachedViews：默認大小為2，通常用來存儲預取的ViewHolder，同時在回收ViewHolder時，也會可能存儲一部分的ViewHolder，這部分的ViewHolder通常來說，意義跟一級緩存差不多；
（2）mRecyclerPool：根據ViewType來緩存ViewHolder，每個ViewType的數組大小為5，可以動態的改變；
（3）mViewCacheExtension：自定義緩存；
RecyclerView總共有4級緩存：
第一級緩存：Scrap部分；
第二級緩存：mCachedViews；
第三級緩存：mViewCacheExtension；
第四級緩存：mRecyclerPool；
那么具體是怎么實現的呢，讓我們根據源碼來分析吧；
首頁我們先看看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;
}
這里最終調用的是tryGetViewHolderForPositionByDeadline();
繼續分析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）第一步：
首先，先判斷是否是預布局，也就是dispatchLayoutStep1()，這個方法在上一篇博客也已經分析過了，具體可以點擊查看；
判斷如果是的話則從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添加標記位（ViewHolder.FLAG_RETURNED_FROM_SCRAP），表示是從Scrap這個緩存里面獲取的；
（2）第二步：
第二步通過getScrapOrHiddenOrCachedHolderForPosition()方法來獲取緩存，讓我們看源碼繼續分析：
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添加標記位（ViewHolder.FLAG_RETURNED_FROM_SCRAP），表示是從Scrap這個緩存里面獲取的；mChildHelper里的mHiddenViews是與動畫相關的緩存獲取，這里就不進行分析了；那么如果從mChangedScrap獲取不到ViewHolder，下面就會從mCachedViews里面獲取緩存；
validateViewHolderForOffsetPosition()這個方法是用來判斷ViewHoler是否有效，如果無效了，則進行回收，具體操作在recycleViewHolderInternal(holder)這個方法里，后面會進行詳細分析；
（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);
這里是抽象方法，具體獲取邏輯由子類實現；
（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();
}
}
當上面的幾步都獲取不到ViewHolder時，則通過調用Adapter的onCreateViewHolder()方法來創建一個ViewHolder并返回給RecyclerView；
那么到這里ViewHolder的獲取就分析完畢了；
2，ViewHolder的回收流程：
先來看一張詳細的流程圖：
這里把復雜的源碼通過流程圖展示出來，源碼的細節就不過多的描述了；
從上面的流程圖可以看出，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的大小是否已經超過最大，是的話則移除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默認對應可以存5個ViewHolder的緩存；
static class ScrapData {
final ArrayList<ViewHolder> mScrapHeap = new ArrayList<>();
int mMaxScrap = DEFAULT_MAX_SCRAP; // 默認5個緩存的大小；
long mCreateRunningAverageNs = 0;
long mBindRunningAverageNs = 0;
}
當然這個值是可以修改的，通過setMaxRecycledViews(int viewType, int max)這個方法來進行設置；
然后到這里你會發現，這里只用了mCachedViews和RecycledViewPool來做緩存，上面提到的Scrap部分和ViewCacheExtension部分呢？別急，后面我們繼續來分析這兩者是什么時候用到的；
1，Scrap部分
先來看一下Scrap部分，Scrap集合添加ViewHolder的方法主要是在scrapView()這個方法里面，而這個方法被getScrapOrHiddenOrCachedHolderForPosition()和scrapOrRecycleView()這個方法所調用；
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()方法，這個方法的調用時機上面已經提到過了，就是在獲取ViewHolder的時候，這里就不重復了；
那么我們再來看一下這個方法里面的這個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集合里面是存儲的和動畫相關的ViewHolder；
這里獲取了ViewHolder之后就通過scrapView()方法存儲到scrap里面去；
2，接下來分析這個scrapOrRecycleView()方法的調用時機；
這個方法是由detachAndScrapAttachedViews()這個方法來調用的，而調用detachAndScrapAttachedViews()這個方法的地方是LayoutManager里的onLayoutChildren()方法，也就是說，這里的回收是通過觸發LayoutManager的布局來調用的；
這里最終回收的是通過mChildHelper.getChildAt(index)獲取的ViewHolder;
到這里，scrap部分的回收就將完了；
2，ViewCacheExtension部分
接下來分析一下ViewCacheExtension部分的回收，ViewCacheExtension這個自定義緩存的部分，在源碼里面只有取ViewHolder的邏輯，但是沒有存ViewHolder的邏輯，看來谷歌是把ViewCacheExtension回收的邏輯交給開發者自己去實現了，那么這里就不過多的分析了；
那么到這里RecyclerView的緩存機制就分析完了；
