你真的了解ListView的缓存吗

我们都知道ListView的baseAdapter中，使用了一个view的缓存回收机制，我们经常被告知会把不可见的view缓存起来，并且在新的view显示时会重用之前回收的view，实际中在开发时会使用convertView去进行相关处理。那么我们不禁会好奇，这个缓存回收机制到底是怎么实现的？我们不该仅仅会使用BaseAdapter重写各个方法就够了，我们需要往深处去挖点宝藏。今天我们就来看看listView和adapter在视图回收和缓存环节是怎么做到的。

AbsListView

ListView是一个继承自AbsListView的类，要想深入这一部分，我们需要看看AbsListView的源码。AbsListView还是比较复杂的，但是我们可以在ListView的scrollListItemsBy，layoutChildren等方法中看到几个叫mRecycler 和recycleBin的对象，看命名似乎是和视图回收机制重用等有关，mRecycler就是来自AbsListView的，我们可以继续看下去。

1
2
3
4
5
/**
* The data set used to store unused views that should be reused during the next layout
* to avoid creating new ones
*/
final RecycleBin mRecycler = new RecycleBin();

涉及到这个功能，recycleBin是一个RecycleBin对象，RecycleBin是AbsListView的内部类。那我们就来研究一下RecycleBin这个类。
我们先看看这个注释。

1
2
3
4
5
6
7
/**
* The RecycleBin facilitates reuse of views across layouts. The RecycleBin has two levels of
* storage: ActiveViews and ScrapViews. ActiveViews are those views which were onscreen at the
* start of a layout. By construction, they are displaying current information. At the end of
* layout, all views in ActiveViews are demoted to ScrapViews. ScrapViews are old views that
* could potentially be used by the adapter to avoid allocating views unnecessarily.
*/

大意就是RecycleBin实现了布局中view的重用。RecycleBin有两个层级的存储。

  1. ActiveViews ， 布局开始时要在屏幕中显示的view
  2. ScrapViews， 布局结束后所有的ActiveViews就降级为ScrapViews。ScrapViews就是旧view，主要是可能被adapter为了避免不必要的视图分配空间而重用。
    好了，RecycleBin的结构我们搞懂了，那么关于ListView的核心问题就变成了RecycleBin是怎么运用ActiveViews和ScrapViews的了。换句话说就是ActiveViews和ScrapViews是怎么产生、怎么添加、怎么交换的？

嗯，继续看源码。
private View[] mActiveViews = new View[0];
private ArrayList[] mScrapViews;

mActiveViews就是一个ActiveViews堆，可以看到mActiveViews是一个View数组。
mScrapViews是一个ScrapViews堆，是一个ArrayList数组。这里为什么要这样设计存储？我们先卖个关子。
在研究这两个不同层级的View堆前，我们先看看在ListView中怎么使用RecycleBin的。

  1. setAdapter方法中，mRecycler.clear();
  2. setAdapter方法中，设计到了viewType的操作，因为会有不同的视图结构，mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
  3. onMeasure方法中，
1
2
3
if (recycleOnMeasure() && mRecycler.shouldRecycleViewType(((LayoutParams) child.getLayoutParams()).viewType)) {
    mRecycler.addScrapView(child, 0);
}
  1. makeAndAddView方法中，mRecycler.getActiveView(position);
  2. layoutChildren方法中， 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
final RecycleBin recycleBin = mRecycler;
if (dataChanged) {
    for (int i = 0; i < childCount; i++) {
        recycleBin.addScrapView(getChildAt(i), firstPosition+i);
    }
} else {
    recycleBin.fillActiveViews(childCount, firstPosition);
}

// Clear out old views
detachAllViewsFromParent();
recycleBin.removeSkippedScrap();
……
// Flush any cached views that did not get reused above
recycleBin.scrapActiveViews();

其中在layoutChildren中的用法特别典型，我们具体来看一看。
以上的这段代码可以大概看出一些逻辑思路：

  1. 先判断数据是否有改变，如果改变了就将当前的children加到ScrapViews中，否则加到ActiveViews中。
  2. removeSkippedScrap，把旧的view都删掉。
  3. 最后将以上没有被重用的缓存的view都回收掉。将当前的ActiveVies 移动到 ScrapViews。

以上是我们通过这一段代码的一个猜测分析，现在一步步看看源码。
dataChanged是一个AdapterView的boolean变量。
其中ListView 继承自AbsListView, AbsListView 继承自AdapterView，AdapterView继承自ViewGroup.
对dataChanged的赋值主要是在AdapterView中的内部类AdapterDataSetObserver中进行的。我们知道listView的adapter使用了观察者模式。这个是怎么做到的？
我们先看看AdapterDataSetObserver的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class AdapterDataSetObserver extends DataSetObserver {

    private Parcelable mInstanceState = null;

    @Override
    public void onChanged() {
        mDataChanged = true;
        mOldItemCount = mItemCount;
        mItemCount = getAdapter().getCount();

        // Detect the case where a cursor that was previously invalidated has
        // been repopulated with new data.
        if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
                && mOldItemCount == 0 && mItemCount > 0) {
            AdapterView.this.onRestoreInstanceState(mInstanceState);
            mInstanceState = null;
        } else {
            rememberSyncState();
        }
        checkFocus();
        requestLayout();
    }

    @Override
    public void onInvalidated() {
        mDataChanged = true;

        if (AdapterView.this.getAdapter().hasStableIds()) {
            // Remember the current state for the case where our hosting activity is being
            // stopped and later restarted
            mInstanceState = AdapterView.this.onSaveInstanceState();
        }

        // Data is invalid so we should reset our state
        mOldItemCount = mItemCount;
        mItemCount = 0;
        mSelectedPosition = INVALID_POSITION;
        mSelectedRowId = INVALID_ROW_ID;
        mNextSelectedPosition = INVALID_POSITION;
        mNextSelectedRowId = INVALID_ROW_ID;
        mNeedSync = false;

        checkFocus();
        requestLayout();
    }

    public void clearSavedState() {
        mInstanceState = null;
    }
}

代码很简单，继承自DataSetObserver，重写了onChanged和onInvalidated两个方法，对mDataChanged的操作都是在数据发生改变后将mDataChanged设为true，那么在哪里会变成false呢？AdapterView中已经没有了。我们还需要回到ListView中继续看。

在ListView中搜索这个变量会发现，将其变为false还是同样的在layoutChildren中，并且是完成了对mActiveViews和mScrapViews的各种操作之后才变为false。
并且在makeAndView中使用了false时的值。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private View makeAndAddView(int position, int y, boolean flow, int childrenLeft, boolean selected) {
    View child;

    if (!mDataChanged) {
        // Try to use an existing view for this position
        child = mRecycler.getActiveView(position);
        if (child != null) {
            // Found it -- we're using an existing child
            // This just needs to be positioned
            setupChild(child, position, y, flow, childrenLeft, selected, true);

            return child;
        }
    }

    // Make a new view for this position, or convert an unused view if possible
    child = obtainView(position, mIsScrap);
    // This needs to be positioned and measured
    setupChild(child, position, y, flow, childrenLeft, selected, mIsScrap[0]);
    return child;
}

makeAndAddView能够获取一个view并且把它添加到child的list中，并且返回了这个child，这个child可以是新view，也可以是没有使用过的view
convert过来的，或者说是从缓存中重用的view。
这当中有一个getActiveView方法，就是我们在之前提到的RecycleBin的第四个用法，也是在mDataChanged为false时一个处理方法。
好了，对mDataChanged的分析和“寻找”先到这里，我们接着看看RecycleBin的用法。

既然是我们之前讲过的处理流程，我们先看看最初的一个RecycleBin使用情况。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void addScrapView(View scrap, int position) {
    final AbsListView.LayoutParams lp = (AbsListView.LayoutParams) scrap.getLayoutParams();
    if (lp == null) {
        return;
    }

    lp.scrappedFromPosition = position;
    ......

    //当一个view有瞬态时不用被废弃
    final boolean scrapHasTransientState = scrap.hasTransientState();
    if (scrapHasTransientState) {
        if (mAdapter != null && mAdapterHasStableIds) {
            // 如果adapter有稳定的ids，那就能对相同的数据进行view的重用
            if (mTransientStateViewsById == null) {
                mTransientStateViewsById = new LongSparseArray<View>();
            }
            mTransientStateViewsById.put(lp.itemId, scrap);
        } else if (!mDataChanged) {
            // 如果绑定的数据没有改变，就能在旧位置重用view
            if (mTransientStateViews == null) {
                mTransientStateViews = new SparseArray<View>();
            }
            mTransientStateViews.put(position, scrap);
        } else {
            // 其他情况只能移除view并且从头来过
            if (mSkippedScrap == null) {
                mSkippedScrap = new ArrayList<View>();
            }
            mSkippedScrap.add(scrap);
        }
    }else{
        if (mViewTypeCount == 1) {
            //这里的mCurrentScrap就是mScrapViews[0]
            mCurrentScrap.add(scrap);
        } else {
            mScrapViews[viewType].add(scrap);
        }

        if (mRecyclerListener != null) {
            mRecyclerListener.onMovedToScrapHeap(scrap);
        }
    }
}

我们可以看到，这里的逻辑还算很清晰，在关于view的重用的判断时，涉及到一个概念还是需要解释一下，就是view的瞬态。
View.hasTransientState()的代码就不贴了，主要是几个flag的运算，虽然就一行，但是需要前后联系，感兴趣的朋友可以去看看源码。
我们这里主要理解瞬态，当我们说一个view有瞬态时，我们指app无需再关心这个view的保存与恢复，注释指出一般用来播放动画或者记录选择的位置等相似的行为。
当一个view标记位有瞬态时，在RecycleBin中，就有可能不会降级到ScrapView,而是mTransientStateViews或者mTransientStateViewsById将其保存起来，以便于
后来的重用。 

1
2
private SparseArray<View> mTransientStateViews;
private LongSparseArray<View> mTransientStateViewsById;

在RecycleBin中涉及到瞬态的存储结构是上述代码中的两个，其实就是SparseArray，一个存的是position的key，一个存的是id。

这里介绍了mTransientStateViews的写，我们再看看mTransientStateViews的读。这里的读也是读的SparseArray,虽然功能类似于HashMap,但是读数据时使用
的是valueAt方法。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
View getTransientStateView(int position) {
    if (mAdapter != null && mAdapterHasStableIds && mTransientStateViewsById != null) {
        long id = mAdapter.getItemId(position);
        View result = mTransientStateViewsById.get(id);
        mTransientStateViewsById.remove(id);
        return result;
    }
    if (mTransientStateViews != null) {
        final int index = mTransientStateViews.indexOfKey(position);
        if (index >= 0) {
            View result = mTransientStateViews.valueAt(index);
            mTransientStateViews.removeAt(index);
            return result;
        }
    }
    return null;
}

上面这份代码就是用来获取瞬时态的view的，首先从mTransientStateViewsById中读取，如果没有就从mTransientStateViews中读取。
这个方法是属于RecycleBin的，但是这个是在哪里调用的呢？答案是AbsListView的obtainView方法。

这里是一个比较关键的地方了。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
View obtainView(int position, boolean[] isScrap) {
    ......

    final View transientView = mRecycler.getTransientStateView(position);
    if (transientView != null) {
        final LayoutParams params = (LayoutParams) transientView.getLayoutParams();

        // If the view type hasn't changed, attempt to re-bind the data.
        if (params.viewType == mAdapter.getItemViewType(position)) {
            final View updatedView = mAdapter.getView(position, transientView, this);

            // 重新绑定数据失败，就废弃获取到的view
            if (updatedView != transientView) {
                setItemViewLayoutParams(updatedView, position);
                mRecycler.addScrapView(updatedView, position);
            }
        }
        ......
        return transientView;
    }

    final View scrapView = mRecycler.getScrapView(position);
    final View child = mAdapter.getView(position, scrapView, this);
    if (scrapView != null) {
        if (child != scrapView) {
            // Failed to re-bind the data, return scrap to the heap.
            mRecycler.addScrapView(scrapView, position);
        } else {
            isScrap[0] = true;

            child.dispatchFinishTemporaryDetach();
        }
    }

    ......

    setItemViewLayoutParams(child, position);

    ......

    return child;
}

阅读代码可以发现，在obtainView中，最重要的一个方法就是调用了adapter的getView方法，这个方法也是我们平常重写的方法，getView返回的是一个view。
而在对这个view的获取过程，有一个很明显的两层处理，首先就是尝试获取我们之前分析介绍的transientView，也就是拥有瞬时态的view，通过transientView
以完成复用。如果这一步走的失败了，也就是transientView为null时，或者说这个view并不拥有瞬时态，那么就从ScrapView中获取一个scrapView,这里可能要对
scrapView多做一些处理，我在上面都省略了，不影响逻辑大局，感兴趣的朋友可以去看看源码。最后返回的是scrapView。

getTransientStateView我们已经介绍过了，现在来看看失败之后的getScrapView。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
View getScrapView(int position) {
    if (mViewTypeCount == 1) {
        return retrieveFromScrap(mCurrentScrap, position);
    } else {
        final int whichScrap = mAdapter.getItemViewType(position);
        if (whichScrap >= 0 && whichScrap < mScrapViews.length) {
            return retrieveFromScrap(mScrapViews[whichScrap], position);
        }
    }
    return null;
}

private View retrieveFromScrap(ArrayList<View> scrapViews, int position) {
    final int size = scrapViews.size();
    if (size > 0) {
        // 检查对某一个position或者id是否还有一个对应的view
        for (int i = 0; i < size; i++) {
            final View view = scrapViews.get(i);
            final AbsListView.LayoutParams params = (AbsListView.LayoutParams) view.getLayoutParams();

            if (mAdapterHasStableIds) {
                final long id = mAdapter.getItemId(position);
                if (id == params.itemId) {
                    return scrapViews.remove(i);
                }
            } else if (params.scrappedFromPosition == position) {
                final View scrap = scrapViews.remove(i);
                clearAccessibilityFromScrap(scrap);
                return scrap;
            }
        }
        final View scrap = scrapViews.remove(size - 1);
        clearAccessibilityFromScrap(scrap);
        return scrap;
    } else {
        return null;
    }
}

上面这份代码还是写的很清楚了，根据不同的viewType来进行不同策略的取scrapView,但是实质上都是走到了retrieveFromScrap。
思路还是比较清晰，但是需要注意的是在get到scrapView后，在scrapView堆中这个view就会被移除掉。以便以后不停的循环往复的重用。

以上的分析都是在layoutChildren中判断数据改变后的过程，当数据没有改变时，会走到fillActiveViews方法。这个方法能够将AbsListView的所有子view都
装到activeViews中。代码很简单，就是一个for循环，将listView的所有子view一一存到activeViews中。

接着我们最初的分析，这些都走完之后，会执行recycleBin的removeSkippedScrap方法。还记得我们介绍的addScrapView方法吗，当一个view是有瞬时态的，但是
却没有一个保存到mTransientStateViewsById或者mTransientStateViews中时，会存在mSkippedScrap中。这是都会通过removeSkippedScrap全部清空。

在layoutChildren中，涉及到RecycleBin的最后还有一个方法就是scrapActiveViews。因为已经完成了children的布局layout位置的摆放等，所以这个时候需要刷新
缓存，scrapActiveViews这部分代码可能处理的过程有点多，但是最重要的一件事就是将现在mActiveViews还剩下的views都会移到mScrapViews中。

这个迁移过程也是和addScrapView的过程差不多。一开始是先对mActiveViews遍历，每次保存当前结点victim，并将mActiveViews[i]置空，然后对victim进行迁移
操作，如果符合条件就加到mTransientStateViewsById或者mTransientStateViews中，否则就加到mScrapViews中。

好了，至此在addScrapView中对RecycleBin进行的一系列操作就讲完了，我们看看下一步是什么。

ListView的makeAndAddView方法。
makeAndAddView的代码我们之前也贴过了，当判断数据没有发生改变时，会走到RecycleBin的getActiveView方法。
那我们来看看getActiveView。 

1
2
3
4
5
6
7
8
9
10
View getActiveView(int position) {
    int index = position - mFirstActivePosition;
    final View[] activeViews = mActiveViews;
    if (index >=0 && index < activeViews.length) {
        final View match = activeViews[index];
        activeViews[index] = null;
        return match;
    }
    return null;
}

getActiveView的代码就很简单了，根据丢过来的position计算出一个真实有效的index，然后从activeViews中获取相应的view。没什么可讲的。

ok，关于RecycleBin的几个主要方法和执行流程就介绍完了。

我们可以暂时回顾小结一下，实际上RecycleBin的主要结构就是三个，一个是activeView堆，结构是一个View数组，另一个是scrapView堆，结构是一个
ArrayList数组。还有一个是transientViews，结构是SparseArray,主要通过Id或者position存取。
几个结构可以理解为层级不同，activeView比scrapView高一点，当触发了某种条件或者机制后，child的view就会从activieView中移到transientViews或者scrapView中进行缓存。
当ListView需要obtainView时，会先从有瞬时态的sparseArray中获取view，当失败时就会去scrapViews中获取view。
当然，这些过程又是和一个boolean变量mDataChanged进行配合的，具体的过程在上面的源码分析中已经解释过了，诸位可以回过去看看。
基本思路是在给子view布局时，如果数据没有发生改变，就使用当前已经存在ActiveViews的view。
在obtainView时，如果发生了改变，就addScrapView.否则就fill with activeView..

再次说到addScrapView,由于这是一个比较重要的方法，这里小结时我们也来看看哪些地方调用了addScrapView.
我们可以在ListView源码中搜索addScrapView看看。

  1. onMeasure
  2. measureHeightOfChildren , measure listView指定范围的高度， 在onMeasure中调用
  3. layoutChildren
  4. scrollListItemsBy , 以一定child数目滑动List，需要将滑出的child删掉，在最后添加view

其实前三个中用到的addScrapView我们之前也已经都讲到了，addScrapView的实现过程也不算复杂，主要是和activeView以及有瞬态的view的配合使用。
第四个我们接下来讲一下。

既然了解了RecycleBin的缓存结构和基本方法后，我们来实战看看，在一个Listview滑动过程中，到底是怎么实现view的回收的吧。

现在考虑滑动一个ListView的情况，也就是scrollListItemsBy方法。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
private void scrollListItemsBy(int amount) {
	...
	final AbsListView.RecycleBin recycleBin = mRecycler;
	if (amount < 0) { //上滑
		...
		View last = getChildAt(numChildren - 1);
		while (last.getBottom() < listBottom) {
			final int lastVisiblePosition = mFirstPosition + numChildren - 1;
			if (lastVisiblePosition < mItemCount - 1) {
				last = addViewBelow(last, lastVisiblePosition);
				numChildren++;
			}
			...
		}
		...
		View first = getChildAt(0);
		while (first.getBottom() < listTop) {
			AbsListView.LayoutParams layoutParams = (LayoutParams) first.getLayoutParams();
			if (recycleBin.shouldRecycleViewType(layoutParams.viewType)) {
				recycleBin.addScrapView(first, mFirstPosition);
			}
			...
		}
		...
	}else{ //往下滑
		...
		View last = getChildAt(lastIndex);
		...
		if (recycleBin.shouldRecycleViewType(layoutParams.viewType)) {
			recycleBin.addScrapView(last, mFirstPosition + lastIndex);
		}
		...
	}
}

可以看到，每次ListView的滑动事件要将一个view滑出屏幕时，会将头部的或者尾部的（视方向而定）childView通过addScrapView缓存起来，
缓存的流程就是我们一开始分析的了，先保存有瞬时态的view，然后视情况存到scrapViews中。

等到每次obtainView时再依序从缓存的view中取出来。

这样就完成了一个滑动的缓存与回收。

好了，关于ListView的回收机制到这里就讲的差不多了，本质上就是对AbsListView的内部类RecycleBin的操作。
当我们弄懂了这个机制，才能更好的思考更多的问题。

例如，最后我问大家一个问题：

根据我之前所讲的，当一个ListView的有若干个viewType, 当滑出的view和滑入添加的view的type不一样，比如说滑出了一个TextView的item,
滑入了一个ImageView的Item, 那这种情况下还能复用刚才的view吗？