Android ListView异步加载图片乱序问题，原因分析及解决方案

旧城等待， 2022-06-06 12:51 199阅读 0赞

在Android所有系统自带的控件当中，ListView这个控件算是用法比较复杂的了，关键是用法复杂也就算了，它还经常会出现一些稀奇古怪的问题，让人非常头疼。比如说在ListView中加载图片，如果是同步加载图片倒还好，但是一旦使用异步加载图片那么问题就来了，这个问题我相信很多Android开发者都曾经遇到过，就是异步加载图片会出现错位乱序的情况。遇到这个问题时，不少人在网上搜索找到了相应的解决方案，但是真正深入理解这个问题出现的原因并对症解决的人恐怕还并不是很多。那么今天我们就来具体深入分析一下ListView异步加载图片出现乱序问题的原因，以及怎么样对症下药去解决它。

本篇文章的原理基础建立在上一篇文章之上，如果你对ListView的工作原理还不够了解的话，建议先去阅读 [**Android ListView工作原理完全解析，带你从源码的角度彻底理解**][Android ListView] 。

## 问题重现 ##

要想解决问题首先我们要把问题重现出来，这里只需要搭建一个最基本的ListView项目，然后在ListView中去异步请求图片并显示，问题就能够得以重现了，那么我们就新建一个ListViewTest项目。

项目建好之后第一个要解决的是数据源的问题，由于ListView中需要从网络上请求图片，那么我就提前准备好了许多张图片，将它们上传到了我的CSDN相册当中，然后新建一个Images类，将所有相册中图片的URL地址都配置进去就可以了，代码如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\* 
2.   \* 原文地址: http://blog.csdn.net/guolin\_blog/article/details/45586553 
3.   \* @author guolin 
4.   \*/  
5.  **public** **class** Images \{  
6.    
7.      **public** **final** **static** String\[\] imageUrls = **new** String\[\] \{  
8.          "https://img-my.csdn.net/uploads/201508/05/1438760758\_3497.jpg",    
9.          "https://img-my.csdn.net/uploads/201508/05/1438760758\_6667.jpg",  
10.         "https://img-my.csdn.net/uploads/201508/05/1438760757\_3588.jpg",  
11.         "https://img-my.csdn.net/uploads/201508/05/1438760756\_3304.jpg",  
12.         "https://img-my.csdn.net/uploads/201508/05/1438760755\_6715.jpeg",  
13.         "https://img-my.csdn.net/uploads/201508/05/1438760726\_5120.jpg",  
14.         "https://img-my.csdn.net/uploads/201508/05/1438760726\_8364.jpg",  
15.         "https://img-my.csdn.net/uploads/201508/05/1438760725\_4031.jpg",  
16.         "https://img-my.csdn.net/uploads/201508/05/1438760724\_9463.jpg",  
17.         "https://img-my.csdn.net/uploads/201508/05/1438760724\_2371.jpg",  
18.         "https://img-my.csdn.net/uploads/201508/05/1438760707\_4653.jpg",  
19.         "https://img-my.csdn.net/uploads/201508/05/1438760706\_6864.jpg",  
20.         "https://img-my.csdn.net/uploads/201508/05/1438760706\_9279.jpg",  
21.         "https://img-my.csdn.net/uploads/201508/05/1438760704\_2341.jpg",  
22.         "https://img-my.csdn.net/uploads/201508/05/1438760704\_5707.jpg",  
23.         "https://img-my.csdn.net/uploads/201508/05/1438760685\_5091.jpg",  
24.         "https://img-my.csdn.net/uploads/201508/05/1438760685\_4444.jpg",  
25.         "https://img-my.csdn.net/uploads/201508/05/1438760684\_8827.jpg",  
26.         "https://img-my.csdn.net/uploads/201508/05/1438760683\_3691.jpg",  
27.         "https://img-my.csdn.net/uploads/201508/05/1438760683\_7315.jpg",  
28.         "https://img-my.csdn.net/uploads/201508/05/1438760663\_7318.jpg",  
29.         "https://img-my.csdn.net/uploads/201508/05/1438760662\_3454.jpg",  
30.         "https://img-my.csdn.net/uploads/201508/05/1438760662\_5113.jpg",  
31.         "https://img-my.csdn.net/uploads/201508/05/1438760661\_3305.jpg",  
32.         "https://img-my.csdn.net/uploads/201508/05/1438760661\_7416.jpg",  
33.         "https://img-my.csdn.net/uploads/201508/05/1438760589\_2946.jpg",  
34.         "https://img-my.csdn.net/uploads/201508/05/1438760589\_1100.jpg",  
35.         "https://img-my.csdn.net/uploads/201508/05/1438760588\_8297.jpg",  
36.         "https://img-my.csdn.net/uploads/201508/05/1438760587\_2575.jpg",  
37.         "https://img-my.csdn.net/uploads/201508/05/1438760587\_8906.jpg",  
38.         "https://img-my.csdn.net/uploads/201508/05/1438760550\_2875.jpg",  
39.         "https://img-my.csdn.net/uploads/201508/05/1438760550\_9517.jpg",  
40.         "https://img-my.csdn.net/uploads/201508/05/1438760549\_7093.jpg",  
41.         "https://img-my.csdn.net/uploads/201508/05/1438760549\_1352.jpg",  
42.         "https://img-my.csdn.net/uploads/201508/05/1438760548\_2780.jpg",  
43.         "https://img-my.csdn.net/uploads/201508/05/1438760531\_1776.jpg",  
44.         "https://img-my.csdn.net/uploads/201508/05/1438760531\_1380.jpg",  
45.         "https://img-my.csdn.net/uploads/201508/05/1438760530\_4944.jpg",  
46.         "https://img-my.csdn.net/uploads/201508/05/1438760530\_5750.jpg",  
47.         "https://img-my.csdn.net/uploads/201508/05/1438760529\_3289.jpg",  
48.         "https://img-my.csdn.net/uploads/201508/05/1438760500\_7871.jpg",  
49.         "https://img-my.csdn.net/uploads/201508/05/1438760500\_6063.jpg",  
50.         "https://img-my.csdn.net/uploads/201508/05/1438760499\_6304.jpeg",  
51.         "https://img-my.csdn.net/uploads/201508/05/1438760499\_5081.jpg",  
52.         "https://img-my.csdn.net/uploads/201508/05/1438760498\_7007.jpg",  
53.         "https://img-my.csdn.net/uploads/201508/05/1438760478\_3128.jpg",  
54.         "https://img-my.csdn.net/uploads/201508/05/1438760478\_6766.jpg",  
55.         "https://img-my.csdn.net/uploads/201508/05/1438760477\_1358.jpg",  
56.         "https://img-my.csdn.net/uploads/201508/05/1438760477\_3540.jpg",  
57.         "https://img-my.csdn.net/uploads/201508/05/1438760476\_1240.jpg",  
58.         "https://img-my.csdn.net/uploads/201508/05/1438760446\_7993.jpg",  
59.         "https://img-my.csdn.net/uploads/201508/05/1438760446\_3641.jpg",  
60.         "https://img-my.csdn.net/uploads/201508/05/1438760445\_3283.jpg",  
61.         "https://img-my.csdn.net/uploads/201508/05/1438760444\_8623.jpg",  
62.         "https://img-my.csdn.net/uploads/201508/05/1438760444\_6822.jpg",  
63.         "https://img-my.csdn.net/uploads/201508/05/1438760422\_2224.jpg",  
64.         "https://img-my.csdn.net/uploads/201508/05/1438760421\_2824.jpg",  
65.         "https://img-my.csdn.net/uploads/201508/05/1438760420\_2660.jpg",  
66.         "https://img-my.csdn.net/uploads/201508/05/1438760420\_7188.jpg",  
67.         "https://img-my.csdn.net/uploads/201508/05/1438760419\_4123.jpg",  
68.     \};  
69. \}

设置好了图片源之后，我们需要一个ListView来展示所有的图片。打开或修改activity\_main.xml中的代码，如下所示：

**\[html\]**  [view plain][]   [copy][view plain]

1.  **<****LinearLayout** xmlns:android="http://schemas.android.com/apk/res/android"  
2.      android:layout\_width="match\_parent"  
3.      android:layout\_height="match\_parent"   
4.      android:orientation="vertical"**>**  
5.    
6.      **<****ListView**  
7.          android:id="@+id/list\_view"  
8.          android:layout\_width="match\_parent"  
9.          android:layout\_height="match\_parent"  
10.         **>**  
11.     **</****ListView****>**  
12.   
13. **</****LinearLayout****>**

很简单，只是在LinearLayout中写了一个ListView而已。接着我们要定义ListView中每一个子View的布局，新建一个image\_item.xml布局，加入如下代码：

**\[html\]**  [view plain][]   [copy][view plain]

1.  **<?****xml** version="1.0" encoding="utf-8"**?>**  
2.  **<****LinearLayout** xmlns:android="http://schemas.android.com/apk/res/android"  
3.      android:layout\_width="match\_parent"  
4.      android:layout\_height="match\_parent" **>**  
5.    
6.      **<****ImageView**  
7.          android:id="@+id/image"  
8.          android:layout\_width="match\_parent"  
9.          android:layout\_height="120dp"  
10.         android:src="@drawable/empty\_photo"   
11.         android:scaleType="fitXY"**/>**  
12.   
13. **</****LinearLayout****>**

仍然很简单，image\_item.xml布局中只有一个ImageView控件，就是用它来显示图片的，控件在默认情况下会显示一张empty\_photo。这样我们就把所有的布局文件都写好了。

接下来新建ImageAdapter做为ListView的适配器，代码如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.   \* 原文地址: http://blog.csdn.net/guolin\_blog/article/details/45586553  
3.   \* @author guolin  
4.   \*/    
5.  **public** **class** ImageAdapter **extends** ArrayAdapter<String> \{  
6.    
7.      /\*\* 
8.       \* 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。 
9.       \*/  
10.     **private** LruCache<String, BitmapDrawable> mMemoryCache;  
11.   
12.     **public** ImageAdapter(Context context, **int** resource, String\[\] objects) \{  
13.         **super**(context, resource, objects);  
14.         // 获取应用程序最大可用内存  
15.         **int** maxMemory = (**int**) Runtime.getRuntime().maxMemory();  
16.         **int** cacheSize = maxMemory / 8;  
17.         mMemoryCache = **new** LruCache<String, BitmapDrawable>(cacheSize) \{  
18.             @Override  
19.             **protected** **int** sizeOf(String key, BitmapDrawable drawable) \{  
20.                 **return** drawable.getBitmap().getByteCount();  
21.             \}  
22.         \};  
23.     \}  
24.   
25.     @Override  
26.     **public** View getView(**int** position, View convertView, ViewGroup parent) \{  
27.         String url = getItem(position);  
28.         View view;  
29.         **if** (convertView == **null**) \{  
30.             view = LayoutInflater.from(getContext()).inflate(R.layout.image\_item, **null**);  
31.         \} **else** \{  
32.             view = convertView;  
33.         \}  
34.         ImageView image = (ImageView) view.findViewById(R.id.image);  
35.         BitmapDrawable drawable = getBitmapFromMemoryCache(url);  
36.         **if** (drawable != **null**) \{  
37.             image.setImageDrawable(drawable);  
38.         \} **else** \{  
39.             BitmapWorkerTask task = **new** BitmapWorkerTask(image);  
40.             task.execute(url);  
41.         \}  
42.         **return** view;  
43.     \}  
44.   
45.     /\*\* 
46.      \* 将一张图片存储到LruCache中。 
47.      \*  
48.      \* @param key 
49.      \*            LruCache的键，这里传入图片的URL地址。 
50.      \* @param drawable 
51.      \*            LruCache的值，这里传入从网络上下载的BitmapDrawable对象。 
52.      \*/  
53.     **public** **void** addBitmapToMemoryCache(String key, BitmapDrawable drawable) \{  
54.         **if** (getBitmapFromMemoryCache(key) == **null**) \{  
55.             mMemoryCache.put(key, drawable);  
56.         \}  
57.     \}  
58.   
59.     /\*\* 
60.      \* 从LruCache中获取一张图片，如果不存在就返回null。 
61.      \*  
62.      \* @param key 
63.      \*            LruCache的键，这里传入图片的URL地址。 
64.      \* @return 对应传入键的BitmapDrawable对象，或者null。 
65.      \*/  
66.     **public** BitmapDrawable getBitmapFromMemoryCache(String key) \{  
67.         **return** mMemoryCache.get(key);  
68.     \}  
69.   
70.     /\*\* 
71.      \* 异步下载图片的任务。 
72.      \*  
73.      \* @author guolin 
74.      \*/  
75.     **class** BitmapWorkerTask **extends** AsyncTask<String, Void, BitmapDrawable> \{  
76.   
77.         **private** ImageView mImageView;  
78.   
79.         **public** BitmapWorkerTask(ImageView imageView) \{  
80.             mImageView = imageView;  
81.         \}  
82.   
83.         @Override  
84.         **protected** BitmapDrawable doInBackground(String... params) \{  
85.             String imageUrl = params\[0\];  
86.             // 在后台开始下载图片  
87.             Bitmap bitmap = downloadBitmap(imageUrl);  
88.             BitmapDrawable drawable = **new** BitmapDrawable(getContext().getResources(), bitmap);  
89.             addBitmapToMemoryCache(imageUrl, drawable);  
90.             **return** drawable;  
91.         \}  
92.   
93.         @Override  
94.         **protected** **void** onPostExecute(BitmapDrawable drawable) \{  
95.             **if** (mImageView != **null** && drawable != **null**) \{  
96.                 mImageView.setImageDrawable(drawable);  
97.             \}  
98.         \}  
99.   
100.         /\*\* 
101.          \* 建立HTTP请求，并获取Bitmap对象。 
102.          \*  
103.          \* @param imageUrl 
104.          \*            图片的URL地址 
105.          \* @return 解析后的Bitmap对象 
106.          \*/  
107.         **private** Bitmap downloadBitmap(String imageUrl) \{  
108.             Bitmap bitmap = **null**;  
109.             HttpURLConnection con = **null**;  
110.             **try** \{  
111.                 URL url = **new** URL(imageUrl);  
112.                 con = (HttpURLConnection) url.openConnection();  
113.                 con.setConnectTimeout(5 \* 1000);  
114.                 con.setReadTimeout(10 \* 1000);  
115.                 bitmap = BitmapFactory.decodeStream(con.getInputStream());  
116.             \} **catch** (Exception e) \{  
117.                 e.printStackTrace();  
118.             \} **finally** \{  
119.                 **if** (con != **null**) \{  
120.                     con.disconnect();  
121.                 \}  
122.             \}  
123.             **return** bitmap;  
124.         \}  
125.   
126.     \}  
127.   
128. \}

ImageAdapter中的代码还算是比较简单的，在getView()方法中首先根据当前的位置获取到图片的URL地址，然后使用inflate()方法加载image\_item.xml这个布局，并获取到ImageView控件的实例，接下来开启了一个BitmapWorkerTask异步任务来从网络上加载图片，最终将加载好的图片设置到ImageView上面。注意这里为了防止图片占用过多的内存，我们还是使用了LruCache技术来进行内存控制，对这个技术不熟悉的朋友可以参考我之前的一篇文章 [**Android高效加载大图、多图解决方案，有效避免程序OOM**][Android_OOM] 。

最后，程序主界面的代码就非常简单了，修改MainActivity中的代码，如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\*   
2.   \* 原文地址: http://blog.csdn.net/guolin\_blog/article/details/45586553   
3.   \* @author guolin   
4.   \*/      
5.  **public** **class** MainActivity **extends** Activity \{  
6.        
7.      **private** ListView listView;  
8.        
9.      @Override  
10.     **protected** **void** onCreate(Bundle savedInstanceState) \{  
11.         **super**.onCreate(savedInstanceState);  
12.         setContentView(R.layout.activity\_main);  
13.         listView = (ListView) findViewById(R.id.list\_view);  
14.         ImageAdapter adapter = **new** ImageAdapter(**this**, 0, Images.imageThumbUrls);  
15.         listView.setAdapter(adapter);  
16.     \}  
17.   
18.   
19. \}

这就是整个程序所有的代码了，记得还需要在AndroidManifest.xml中添加INTERNET权限。

那么目前程序的思路其实是很简单的，我们在ListView的getView()方法中开启异步请求，从网络上获取图片，当图片获取成功就后就将图片显示到ImageView上面。看起来没什么问题对吗？那么现在我们就来运行一下程序看一看效果吧。

![1439302562_7693.gif][]

恩？怎么会这个样子，当滑动ListView的时候，图片竟然会自动变来变去，而且图片显示的位置也不正确，简直快乱成一锅粥了！可是我们所有的逻辑都很简单呀，怎么会导致出现这种图片自动变来变去的情况？很遗憾，这是由于Listview内部的工作机制所导致的，如果你对Listview的工作机制不了解，那么就会很难理解这种现象，不过好在上篇文章中我已经讲解过ListView的工作原理了，因此下面就让我们一起分析一下这个问题出现的原因。

## 原因分析 ##

上篇文章中已经提到了，ListView之所以能够实现加载成百上千条数据都不会OOM，最主要在于它内部优秀的实现机制。虽然作为普通的使用者，我们大可不必关心ListView内部到底是怎么实现的，但是当你了解了它的内部原理之后，很多之前难以解释的问题都变得有理有据了。

ListView在借助RecycleBin机制的帮助下，实现了一个生产者和消费者的模式，不管有任意多条数据需要显示，ListView中的子View其实来来回回就那么几个，移出屏幕的子View会很快被移入屏幕的数据重新利用起来，原理示意图如下所示：

![SouthEast][]

那么这里我们就可以思考一下了，目前数据源当中大概有60个图片的URL地址，而根据ListView的工作原理，显然不可能为每张图片都单独分配一个ImageView控件，ImageView控件的个数其实就比一屏能显示的图片数量稍微多一点而已，移出屏幕的ImageView控件会进入到RecycleBin当中，而新进入屏幕的元素则会从RecycleBin中获取ImageView控件。

那么，每当有新的元素进入界面时就会回调getView()方法，而在getView()方法中会开启异步请求从网络上获取图片，注意网络操作都是比较耗时的，也就是说当我们快速滑动ListView的时候就很有可能出现这样一种情况，某一个位置上的元素进入屏幕后开始从网络上请求图片，但是还没等图片下载完成，它就又被移出了屏幕。这种情况下会产生什么样的现象呢？根据ListView的工作原理，被移出屏幕的控件将会很快被新进入屏幕的元素重新利用起来，而如果在这个时候刚好前面发起的图片请求有了响应，就会将刚才位置上的图片显示到当前位置上，因为虽然它们位置不同，但都是共用的同一个ImageView实例，这样就出现了图片乱序的情况。

但是还没完，新进入屏幕的元素它也会发起一条网络请求来获取当前位置的图片，等到图片下载完的时候会设置到同样的ImageView上面，因此就会出现先显示一张图片，然后又变成了另外一张图片的情况，那么刚才我们看到的图片会自动变来变去的情况也就得到了解释。

问题原因已经分析出来了，但是这个问题该怎么解决呢？说实话，ListView异步加载图片的问题并没有什么标准的解决方案，很多人都有自己的一套解决思路，这里我准备给大家讲解三种比较经典的解决办法，大家通过任何一种都可以解决这个问题，但是我们每多学习一种思路，水平就能够更进一步的提高。

## 解决方案一  使用findViewWithTag ##

findViewWithTag算是一种比较简单易懂的解决方案，其实早在 [**Android照片墙应用实现，再多的图片也不怕崩溃**][Android] 这篇文章当中，我就采用了findViewWithTag来避免图片出现乱序的情况。那么这里我们先来看看怎么通过修改代码把这个问题解决掉，然后再研究一下findViewWithTag的工作原理。

使用findViewWithTag并不需要修改太多的代码，只需要改动ImageAdapter这一个类就可以了，如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.   \* 原文地址: http://blog.csdn.net/guolin\_blog/article/details/45586553  
3.   \* @author guolin  
4.   \*/    
5.  **public** **class** ImageAdapter **extends** ArrayAdapter<String> \{  
6.        
7.      **private** ListView mListView;   
8.    
9.      ......  
10.   
11.     @Override  
12.     **public** View getView(**int** position, View convertView, ViewGroup parent) \{  
13.         **if** (mListView == **null**) \{    
14.             mListView = (ListView) parent;    
15.         \}   
16.         String url = getItem(position);  
17.         View view;  
18.         **if** (convertView == **null**) \{  
19.             view = LayoutInflater.from(getContext()).inflate(R.layout.image\_item, **null**);  
20.         \} **else** \{  
21.             view = convertView;  
22.         \}  
23.         ImageView image = (ImageView) view.findViewById(R.id.image);  
24.         image.setImageResource(R.drawable.empty\_photo);  
25.         image.setTag(url);  
26.         BitmapDrawable drawable = getBitmapFromMemoryCache(url);  
27.         **if** (drawable != **null**) \{  
28.             image.setImageDrawable(drawable);  
29.         \} **else** \{  
30.             BitmapWorkerTask task = **new** BitmapWorkerTask();  
31.             task.execute(url);  
32.         \}  
33.         **return** view;  
34.     \}  
35.   
36.     ......  
37.   
38.     /\*\* 
39.      \* 异步下载图片的任务。 
40.      \*  
41.      \* @author guolin 
42.      \*/  
43.     **class** BitmapWorkerTask **extends** AsyncTask<String, Void, BitmapDrawable> \{  
44.   
45.         String imageUrl;   
46.   
47.         @Override  
48.         **protected** BitmapDrawable doInBackground(String... params) \{  
49.             imageUrl = params\[0\];  
50.             // 在后台开始下载图片  
51.             Bitmap bitmap = downloadBitmap(imageUrl);  
52.             BitmapDrawable drawable = **new** BitmapDrawable(getContext().getResources(), bitmap);  
53.             addBitmapToMemoryCache(imageUrl, drawable);  
54.             **return** drawable;  
55.         \}  
56.   
57.         @Override  
58.         **protected** **void** onPostExecute(BitmapDrawable drawable) \{  
59.             ImageView imageView = (ImageView) mListView.findViewWithTag(imageUrl);    
60.             **if** (imageView != **null** && drawable != **null**) \{    
61.                 imageView.setImageDrawable(drawable);    
62.             \}   
63.         \}  
64.   
65.         ......  
66.   
67.     \}  
68.   
69. \}

改动的地方就只有这么多，那么我们来分析一下。由于使用findViewWithTag必须要有ListView的实例才行，那么我们在Adapter中怎样才能拿到ListView的实例呢？其实如果你仔细通读了上一篇文章就能知道，getView()方法中传入的第三个参数其实就是ListView的实例，那么这里我们定义一个全局变量mListView，然后在getView()方法中判断它是否为空，如果为空就把parent这个参数赋值给它。

另外在getView()方法中我们还做了一个操作，就是调用了ImageView的setTag()方法，并把当前位置图片的URL地址作为参数传了进去，这个是为后续的findViewWithTag()方法做准备。

最后，我们修改了BitmapWorkerTask的构造函数，这里不再通过构造函数把ImageView的实例传进去了，而是在onPostExecute()方法当中通过ListView的findVIewWithTag()方法来去获取ImageView控件的实例。获取到控件实例后判断下是否为空，如果不为空就让图片显示到控件上。

这里我们可以尝试分析一下findViewWithTag的工作原理，其实顾名思义，这个方法就是通过Tag的名字来获取具备该Tag名的控件，我们先要调用控件的setTag()方法来给控件设置一个Tag，然后再调用ListView的findViewWithTag()方法使用相同的Tag名来找回控件。

那么为什么用了findViewWithTag()方法之后，图片就不会再出现乱序情况了呢？其实原因很简单，由于ListView中的ImageView控件都是重用的，移出屏幕的控件很快会被进入屏幕的图片重新利用起来，那么getView()方法就会再次得到执行，而在getView()方法中会为这个ImageView控件设置新的Tag，这样老的Tag就会被覆盖掉，于是这时再调用findVIewWithTag()方法并传入老的Tag，就只能得到null了，而我们判断只有ImageView不等于null的时候才会设置图片，这样图片乱序的问题也就不存在了。

这是第一种解决方案。

## 解决方案二  使用弱引用关联 ##

虽然这里我给这种解决方案起名叫弱引用关联，但实际上弱引用只是辅助手段而已，最主要的还是关联，这种解决方案的本质是要让ImageView和BitmapWorkerTask之间建立一个双向关联，互相持有对方的引用，再通过适当的逻辑判断来解决图片乱序问题，然后为了防止出现内存泄漏的情况，双向关联要使用弱引用的方式建立。相比于第一种解决方案，第二种解决方案要明显复杂不少，但在性能和效率方面都会有更好的表现。

我们仍然只需要改动ImageAdapter中的代码，但这次改动的地方比较多，所以我就把ImageAdapter中的全部代码都贴出来了，如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.   \* 原文地址: http://blog.csdn.net/guolin\_blog/article/details/45586553  
3.   \* @author guolin  
4.   \*/    
5.  **public** **class** ImageAdapter **extends** ArrayAdapter<String> \{  
6.        
7.      **private** ListView mListView;   
8.        
9.      **private** Bitmap mLoadingBitmap;  
10.   
11.     /\*\* 
12.      \* 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。 
13.      \*/  
14.     **private** LruCache<String, BitmapDrawable> mMemoryCache;  
15.   
16.     **public** ImageAdapter(Context context, **int** resource, String\[\] objects) \{  
17.         **super**(context, resource, objects);  
18.         mLoadingBitmap = BitmapFactory.decodeResource(context.getResources(),  
19.                 R.drawable.empty\_photo);  
20.         // 获取应用程序最大可用内存  
21.         **int** maxMemory = (**int**) Runtime.getRuntime().maxMemory();  
22.         **int** cacheSize = maxMemory / 8;  
23.         mMemoryCache = **new** LruCache<String, BitmapDrawable>(cacheSize) \{  
24.             @Override  
25.             **protected** **int** sizeOf(String key, BitmapDrawable drawable) \{  
26.                 **return** drawable.getBitmap().getByteCount();  
27.             \}  
28.         \};  
29.     \}  
30.   
31.     @Override  
32.     **public** View getView(**int** position, View convertView, ViewGroup parent) \{  
33.         **if** (mListView == **null**) \{    
34.             mListView = (ListView) parent;    
35.         \}   
36.         String url = getItem(position);  
37.         View view;  
38.         **if** (convertView == **null**) \{  
39.             view = LayoutInflater.from(getContext()).inflate(R.layout.image\_item, **null**);  
40.         \} **else** \{  
41.             view = convertView;  
42.         \}  
43.         ImageView image = (ImageView) view.findViewById(R.id.image);  
44.         BitmapDrawable drawable = getBitmapFromMemoryCache(url);  
45.         **if** (drawable != **null**) \{  
46.             image.setImageDrawable(drawable);  
47.         \} **else** **if** (cancelPotentialWork(url, image)) \{  
48.             BitmapWorkerTask task = **new** BitmapWorkerTask(image);  
49.             AsyncDrawable asyncDrawable = **new** AsyncDrawable(getContext()  
50.                     .getResources(), mLoadingBitmap, task);  
51.             image.setImageDrawable(asyncDrawable);  
52.             task.execute(url);  
53.         \}  
54.         **return** view;  
55.     \}  
56.       
57.     /\*\* 
58.      \* 自定义的一个Drawable，让这个Drawable持有BitmapWorkerTask的弱引用。 
59.      \*/  
60.     **class** AsyncDrawable **extends** BitmapDrawable \{  
61.   
62.         **private** WeakReference<BitmapWorkerTask> bitmapWorkerTaskReference;  
63.   
64.         **public** AsyncDrawable(Resources res, Bitmap bitmap,  
65.                 BitmapWorkerTask bitmapWorkerTask) \{  
66.             **super**(res, bitmap);  
67.             bitmapWorkerTaskReference = **new** WeakReference<BitmapWorkerTask>(  
68.                     bitmapWorkerTask);  
69.         \}  
70.   
71.         **public** BitmapWorkerTask getBitmapWorkerTask() \{  
72.             **return** bitmapWorkerTaskReference.get();  
73.         \}  
74.   
75.     \}  
76.       
77.     /\*\* 
78.      \* 获取传入的ImageView它所对应的BitmapWorkerTask。 
79.      \*/  
80.     **private** BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) \{  
81.         **if** (imageView != **null**) \{  
82.             Drawable drawable = imageView.getDrawable();  
83.             **if** (drawable **instanceof** AsyncDrawable) \{  
84.                 AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;  
85.                 **return** asyncDrawable.getBitmapWorkerTask();  
86.             \}  
87.         \}  
88.         **return** **null**;  
89.     \}  
90.       
91.     /\*\* 
92.      \* 取消掉后台的潜在任务，当认为当前ImageView存在着一个另外图片请求任务时 
93.      \* ，则把它取消掉并返回true，否则返回false。 
94.      \*/  
95.     **public** **boolean** cancelPotentialWork(String url, ImageView imageView) \{  
96.         BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);  
97.         **if** (bitmapWorkerTask != **null**) \{  
98.             String imageUrl = bitmapWorkerTask.imageUrl;  
99.             **if** (imageUrl == **null** || !imageUrl.equals(url)) \{  
100.                 bitmapWorkerTask.cancel(**true**);  
101.             \} **else** \{  
102.                 **return** **false**;  
103.             \}  
104.         \}  
105.         **return** **true**;  
106.     \}  
107.   
108.     /\*\* 
109.      \* 将一张图片存储到LruCache中。 
110.      \*  
111.      \* @param key 
112.      \*            LruCache的键，这里传入图片的URL地址。 
113.      \* @param drawable 
114.      \*            LruCache的值，这里传入从网络上下载的BitmapDrawable对象。 
115.      \*/  
116.     **public** **void** addBitmapToMemoryCache(String key, BitmapDrawable drawable) \{  
117.         **if** (getBitmapFromMemoryCache(key) == **null**) \{  
118.             mMemoryCache.put(key, drawable);  
119.         \}  
120.     \}  
121.   
122.     /\*\* 
123.      \* 从LruCache中获取一张图片，如果不存在就返回null。 
124.      \*  
125.      \* @param key 
126.      \*            LruCache的键，这里传入图片的URL地址。 
127.      \* @return 对应传入键的BitmapDrawable对象，或者null。 
128.      \*/  
129.     **public** BitmapDrawable getBitmapFromMemoryCache(String key) \{  
130.         **return** mMemoryCache.get(key);  
131.     \}  
132.   
133.     /\*\* 
134.      \* 异步下载图片的任务。 
135.      \*  
136.      \* @author guolin 
137.      \*/  
138.     **class** BitmapWorkerTask **extends** AsyncTask<String, Void, BitmapDrawable> \{  
139.   
140.         String imageUrl;   
141.           
142.         **private** WeakReference<ImageView> imageViewReference;  
143.           
144.         **public** BitmapWorkerTask(ImageView imageView) \{    
145.             imageViewReference = **new** WeakReference<ImageView>(imageView);  
146.         \}    
147.   
148.         @Override  
149.         **protected** BitmapDrawable doInBackground(String... params) \{  
150.             imageUrl = params\[0\];  
151.             // 在后台开始下载图片  
152.             Bitmap bitmap = downloadBitmap(imageUrl);  
153.             BitmapDrawable drawable = **new** BitmapDrawable(getContext().getResources(), bitmap);  
154.             addBitmapToMemoryCache(imageUrl, drawable);  
155.             **return** drawable;  
156.         \}  
157.   
158.         @Override  
159.         **protected** **void** onPostExecute(BitmapDrawable drawable) \{  
160.             ImageView imageView = getAttachedImageView();  
161.             **if** (imageView != **null** && drawable != **null**) \{    
162.                 imageView.setImageDrawable(drawable);    
163.             \}   
164.         \}  
165.           
166.         /\*\* 
167.          \* 获取当前BitmapWorkerTask所关联的ImageView。 
168.          \*/  
169.         **private** ImageView getAttachedImageView() \{  
170.             ImageView imageView = imageViewReference.get();  
171.             BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);  
172.             **if** (**this** == bitmapWorkerTask) \{  
173.                 **return** imageView;  
174.             \}  
175.             **return** **null**;  
176.         \}  
177.   
178.         /\*\* 
179.          \* 建立HTTP请求，并获取Bitmap对象。 
180.          \*  
181.          \* @param imageUrl 
182.          \*            图片的URL地址 
183.          \* @return 解析后的Bitmap对象 
184.          \*/  
185.         **private** Bitmap downloadBitmap(String imageUrl) \{  
186.             Bitmap bitmap = **null**;  
187.             HttpURLConnection con = **null**;  
188.             **try** \{  
189.                 URL url = **new** URL(imageUrl);  
190.                 con = (HttpURLConnection) url.openConnection();  
191.                 con.setConnectTimeout(5 \* 1000);  
192.                 con.setReadTimeout(10 \* 1000);  
193.                 bitmap = BitmapFactory.decodeStream(con.getInputStream());  
194.             \} **catch** (Exception e) \{  
195.                 e.printStackTrace();  
196.             \} **finally** \{  
197.                 **if** (con != **null**) \{  
198.                     con.disconnect();  
199.                 \}  
200.             \}  
201.             **return** bitmap;  
202.         \}  
203.   
204.     \}  
205.   
206. \}

那么我们一点点开始解析。首先刚才说到的，ImageView和BitmapWorkerTask之间要建立一个双向的弱引用关联，上述代码中已经建立好了。ImageView中可以获取到它所对应的BitmapWorkerTask，而BitmapWorkerTask也可以获取到它所对应的ImageView。

下面来看一下这个双向弱引用关联是怎么建立的。BitmapWorkerTask指向ImageView的弱引用关联比较简单，就是在BitmapWorkerTask中加入一个构造函数，并在构造函数中要求传入ImageView这个参数。不过我们不再直接持有ImageView的引用，而是使用WeakReference对ImageView进行了一层包装，这样就OK了。

但是ImageView指向BitmapWorkerTask的弱引用关联就没这么容易了，因为我们很难将BitmapWorkerTask的一个弱引用直接设置到ImageView当中。这该怎么办呢？这里使用了一个比较巧的方法，就是借助自定义Drawable的方式来实现。可以看到，我们自定义了一个AsyncDrawable类并让它继承自BitmapDrawable，然后重写了AsyncDrawable的构造函数，在构造函数中要求把BitmapWorkerTask传入，然后在这里给它包装了一层弱引用。那么现在AsyncDrawable指向BitmapWorkerTask的关联已经有了，但是ImageView指向BitmapWorkerTask的关联还不存在，怎么办呢？很简单，让ImageView和AsyncDrawable再关联一下就可以了。可以看到，在getView()方法当中，我们调用了ImageView的setImageDrawable()方法把AsyncDrawable设置了进去，那么ImageView就可以通过getDrawable()方法获取到和它关联的AsyncDrawable，然后再借助AsyncDrawable就可以获取到BitmapWorkerTask了。这样ImageView指向BitmapWorkerTask的弱引用关联也成功建立。

现在双向弱引用的关联已经建立好了，接下来就是逻辑判断的工作了。那么怎样通过逻辑判断来避免图片出现乱序的情况呢？这里我们引入了两个方法，一个是getBitmapWorkerTask()方法，这个方法可以根据传入的ImageView来获取到它对应的BitmapWorkerTask，内部的逻辑就是先获取ImageView对应的AsyncDrawable，再获取AsyncDrawable对应的BitmapWorkerTask。另一个是getAttachedImageView()方法，这个方法会获取当前BitmapWorkerTask所关联的ImageView，然后调用getBitmapWorkerTask()方法来获取该ImageView所对应的BitmapWorkerTask，最后判断，如果获取到的BitmapWorkerTask等于this，也就是当前的BitmapWorkerTask，那么就将ImageView返回，否则就返回null。最后，在onPostExecute()方法当中，只需要使用getAttachedImageView()方法获取到的ImageView来显示图片就可以了。

那么为什么做了这个逻辑判断之后，图片乱序的问题就可以得到解决呢？其实最主要的奥秘就是在getAttachedImageView()方法当中，它会使用当前BitmapWorkerTask所关联的ImageView来反向获取这个ImageView所关联的BitmapWorkerTask，然后用这两个BitmapWorkerTask做对比，如果发现是同一个BitmapWorkerTask才会返回ImageView，否则就返回null。那么什么情况下这两个BitmapWorkerTask才会不同呢？比如说某个图片被移出了屏幕，它的ImageView被另外一个新进入屏幕的图片重用了，那么就会给这个ImageView关联一个新的BitmapWorkerTask，这种情况下，上一个BitmapWorkerTask和新的BitmapWorkerTask肯定就不相等了，这时getAttachedImageView()方法会返回null，而我们又判断ImageView等于null的话是不会设置图片的，因此就不会出现图片乱序的情况了。

除此之外还有另外一个方法非常值得大家注意，就是cancelPotentialWork()方法，这个方法可以大大提高整个ListView图片加载的工作效率。这个方法接收两个参数，一个图片的url，一个ImageView。看一下它的内部逻辑，首先它也是调用了getBitmapWorkerTask()方法来获取传入的ImageView所对应的BitmapWorkerTask，接下来拿BitmapWorkerTask中的imageUrl和传入的url做比较，如果两个url不等的话就调用BitmapWorkerTask的cancel()方法，然后返回true，如果两个url相等的话就返回false。

那么这段逻辑是什么意思呢？其实并不复杂，两个url做比对时，如果发现是相同的，说明请求的是同一张图片，那么直接返回false，这样就不会再去启动BitmapWorkerTask来请求图片，而如果两个url不相同，说明这个ImageView被另外一张图片重新利用了，这个时候就调用了BitmapWorkerTask的cancel()方法把之前的请求取消掉，然后重新启动BitmapWorkerTask来去请求新图片。有了这个操作保护之后，就可以把一些已经移出屏幕的无效的图片请求过滤掉，从而整体提升ListView加载图片的工作效率。

这是第二种解决方案。

## 解决方案三  使用NetworkImageView ##

前面两种解决方案都需要我们自己去做额外的逻辑处理，因为ImageView本身是不能自动解决这个问题的，但是如果我们使用NetworkImageView这个控件的话就非常简单了，它自身就已经考虑到了这个问题，我们直接使用它就可以了，不用做任何额外的处理也不会出现图片乱序的情况。

NetworkImageView是Volley当中提供的控件，对于这个控件我之前专门写过一篇博客来讲解，还不熟悉这个控件的朋友可以先去阅读 [Android Volley完全解析(二)，使用Volley加载网络图片][Android Volley_Volley]。

下面我们看一下如何用NetworkImageView来解决这个问题，首先需要修改一下image\_item.xml文件，因为我们已经不再使用ImageView控件了，代码如下所示：

**\[html\]**  [view plain][]   [copy][view plain]

1.  **<?****xml** version="1.0" encoding="utf-8"**?>**  
2.  **<****LinearLayout** xmlns:android="http://schemas.android.com/apk/res/android"  
3.      android:layout\_width="match\_parent"  
4.      android:layout\_height="match\_parent" **>**  
5.    
6.      **<****com.android.volley.toolbox.NetworkImageView**  
7.          android:id="@+id/image"  
8.          android:layout\_width="match\_parent"  
9.          android:layout\_height="120dp"  
10.         android:src="@drawable/empty\_photo"   
11.         android:scaleType="fitXY"**/>**  
12.   
13. **</****LinearLayout****>**

很简单，只是把ImageView替换成了NetworkImageView。然后修改ImageAdapter中的代码，如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\* 
2.   \* 原文地址: http://blog.csdn.net/guolin\_blog/article/details/45586553 
3.   \* @author guolin 
4.   \*/  
5.  **public** **class** ImageAdapter **extends** ArrayAdapter<String> \{  
6.        
7.      ImageLoader mImageLoader;  
8.    
9.      **public** ImageAdapter(Context context, **int** resource, String\[\] objects) \{  
10.         **super**(context, resource, objects);  
11.         RequestQueue queue = Volley.newRequestQueue(context);  
12.         mImageLoader = **new** ImageLoader(queue, **new** BitmapCache());  
13.     \}  
14.   
15.     @Override  
16.     **public** View getView(**int** position, View convertView, ViewGroup parent) \{  
17.         String url = getItem(position);  
18.         View view;  
19.         **if** (convertView == **null**) \{  
20.             view = LayoutInflater.from(getContext()).inflate(R.layout.image\_item, **null**);  
21.         \} **else** \{  
22.             view = convertView;  
23.         \}  
24.         NetworkImageView image = (NetworkImageView) view.findViewById(R.id.image);  
25.         image.setDefaultImageResId(R.drawable.empty\_photo);  
26.         image.setErrorImageResId(R.drawable.empty\_photo);  
27.         image.setImageUrl(url, mImageLoader);  
28.         **return** view;  
29.     \}  
30.   
31.     /\*\* 
32.      \* 使用LruCache来缓存图片 
33.      \*/  
34.     **public** **class** BitmapCache **implements** ImageCache \{  
35.   
36.         **private** LruCache<String, Bitmap> mCache;  
37.   
38.         **public** BitmapCache() \{  
39.             // 获取应用程序最大可用内存  
40.             **int** maxMemory = (**int**) Runtime.getRuntime().maxMemory();  
41.             **int** cacheSize = maxMemory / 8;  
42.             mCache = **new** LruCache<String, Bitmap>(cacheSize) \{  
43.                 @Override  
44.                 **protected** **int** sizeOf(String key, Bitmap bitmap) \{  
45.                     **return** bitmap.getRowBytes() \* bitmap.getHeight();  
46.                 \}  
47.             \};  
48.         \}  
49.   
50.         @Override  
51.         **public** Bitmap getBitmap(String url) \{  
52.             **return** mCache.get(url);  
53.         \}  
54.   
55.         @Override  
56.         **public** **void** putBitmap(String url, Bitmap bitmap) \{  
57.             mCache.put(url, bitmap);  
58.         \}  
59.   
60.     \}  
61.   
62. \}

没错，就是这么简单，一共60行左右的代码搞定一切！我们不需要自己再去写一个BitmapWorkerTask来处理图片的下载和显示，也不需要自己再去管理LruCache的逻辑，一切NetworkImageView都帮我们做好了。至于上面的代码我就不再做解释了，因为实在是太简单了。

那么当然了，虽然现在没有做任何额外的逻辑处理，但是也根本不会出现图片乱序的情况，因为NetworkImageView在内部都帮我们处理掉了。不过大家可能都很好奇，NetworkImageView到底是如何做到的呢？那么就让我们来分析一下它的源码吧。

NetworkImageView中开始加载图片的代码是setImageUrl()方法，源码分析就从这里开始吧，如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\* 
2.   \* Sets URL of the image that should be loaded into this view. Note that calling this will 
3.   \* immediately either set the cached image (if available) or the default image specified by 
4.   \* \{@link NetworkImageView\#setDefaultImageResId(int)\} on the view. 
5.   \* 
6.   \* NOTE: If applicable, \{@link NetworkImageView\#setDefaultImageResId(int)\} and 
7.   \* \{@link NetworkImageView\#setErrorImageResId(int)\} should be called prior to calling 
8.   \* this function. 
9.   \* 
10.  \* @param url The URL that should be loaded into this ImageView. 
11.  \* @param imageLoader ImageLoader that will be used to make the request. 
12.  \*/  
13. **public** **void** setImageUrl(String url, ImageLoader imageLoader) \{  
14.     mUrl = url;  
15.     mImageLoader = imageLoader;  
16.     // The URL has potentially changed. See if we need to load it.  
17.     loadImageIfNecessary(**false**);  
18. \}

setImageUrl()方法中并没有几行代码，让人值得留意的是loadImageIfNecessary()这个方法，看上去具体加载图片的逻辑就是在这里进行的，那么我们就跟进去瞧一瞧：

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\* 
2.   \* Loads the image for the view if it isn't already loaded. 
3.   \* @param isInLayoutPass True if this was invoked from a layout pass, false otherwise. 
4.   \*/  
5.  **private** **void** loadImageIfNecessary(**final** **boolean** isInLayoutPass) \{  
6.      **int** width = getWidth();  
7.      **int** height = getHeight();  
8.    
9.      **boolean** isFullyWrapContent = getLayoutParams() != **null**  
10.             && getLayoutParams().height == LayoutParams.WRAP\_CONTENT  
11.             && getLayoutParams().width == LayoutParams.WRAP\_CONTENT;  
12.     // if the view's bounds aren't known yet, and this is not a wrap-content/wrap-content  
13.     // view, hold off on loading the image.  
14.     **if** (width == 0 && height == 0 && !isFullyWrapContent) \{  
15.         **return**;  
16.     \}  
17.   
18.     // if the URL to be loaded in this view is empty, cancel any old requests and clear the  
19.     // currently loaded image.  
20.     **if** (TextUtils.isEmpty(mUrl)) \{  
21.         **if** (mImageContainer != **null**) \{  
22.             mImageContainer.cancelRequest();  
23.             mImageContainer = **null**;  
24.         \}  
25.         setDefaultImageOrNull();  
26.         **return**;  
27.     \}  
28.   
29.     // if there was an old request in this view, check if it needs to be canceled.  
30.     **if** (mImageContainer != **null** && mImageContainer.getRequestUrl() != **null**) \{  
31.         **if** (mImageContainer.getRequestUrl().equals(mUrl)) \{  
32.             // if the request is from the same URL, return.  
33.             **return**;  
34.         \} **else** \{  
35.             // if there is a pre-existing request, cancel it if it's fetching a different URL.  
36.             mImageContainer.cancelRequest();  
37.             setDefaultImageOrNull();  
38.         \}  
39.     \}  
40.   
41.     // The pre-existing content of this view didn't match the current URL. Load the new image  
42.     // from the network.  
43.     ImageContainer newContainer = mImageLoader.get(mUrl,  
44.             **new** ImageListener() \{  
45.                 @Override  
46.                 **public** **void** onErrorResponse(VolleyError error) \{  
47.                     **if** (mErrorImageId != 0) \{  
48.                         setImageResource(mErrorImageId);  
49.                     \}  
50.                 \}  
51.   
52.                 @Override  
53.                 **public** **void** onResponse(**final** ImageContainer response, **boolean** isImmediate) \{  
54.                     // If this was an immediate response that was delivered inside of a layout  
55.                     // pass do not set the image immediately as it will trigger a requestLayout  
56.                     // inside of a layout. Instead, defer setting the image by posting back to  
57.                     // the main thread.  
58.                     **if** (isImmediate && isInLayoutPass) \{  
59.                         post(**new** Runnable() \{  
60.                             @Override  
61.                             **public** **void** run() \{  
62.                                 onResponse(response, **false**);  
63.                             \}  
64.                         \});  
65.                         **return**;  
66.                     \}  
67.   
68.                     **if** (response.getBitmap() != **null**) \{  
69.                         setImageBitmap(response.getBitmap());  
70.                     \} **else** **if** (mDefaultImageId != 0) \{  
71.                         setImageResource(mDefaultImageId);  
72.                     \}  
73.                 \}  
74.             \});  
75.   
76.     // update the ImageContainer to be the new bitmap container.  
77.     mImageContainer = newContainer;  
78. \}

这里在第43行调用了ImageLoader的get()方法来去请求图片，get()方法会返回一个ImageContainer对象，这个对象封装了图片请求地址、Bitmap等数据，每个NetworkImageView中都会对应一个ImageContainer。然后在第31行我们看到，这里从ImageContainer对象中获取封装的图片请求地址，并拿来和当前的请求地址做对比，如果相同的话说明这是一条重复的请求，就直接return掉，如果不同的话就调用cancelRequest()方法将请求取消掉，然后将图片设置为默认图片并重新发起请求。

那么解决图片乱序最核心的逻辑就在这里了，其实NetworkImageView的解决思路还是比较简单的，就是如果这个控件已经被移出了屏幕且被重新利用了，那么就把之前的请求取消掉，仅此而已。

而我们都知道，在通常情况下，仅仅这么处理可能是解决不了问题的，因为Java的线程无法保证一定可以中断，即使像第二种解决方案里使用的BitmapWorkerTask的cancel()方法，也不能保证一定可以把请求取消掉，所以还需要使用弱引用关联的处理方式。但是在NetworkImageView当中就可以这么任性，仅仅调用cancelRequest()方法把请求取消掉就可以了，这主要是得益于Volley的出色设计。由于Volley在网络方面的封装非常优秀，它可以保证，只要是取消掉的请求，就绝对不会进行回调，既然不会回调，那么也就不会回到NetworkImageView当中，自然也就不会出现乱序的情况了。

需要注意的是，Volley只是保证取消掉的请求不会进行回调而已，但并没有说可以中断任何请求。由此可见即使是Volley也无法做到中断一个正在执行的线程，如果有一个线程正在执行，Volley只会保证在它执行完之后不会进行回调，但在调用者看来，就好像是这个请求就被取消掉了一样。

那么这里我们只分析与图片乱序相关部分的源码，如果你想了解关于Volley更多的源码，可以参考我之前的一篇文章 [**Android Volley完全解析(四)，带你从源码的角度理解Volley**][Android Volley_Volley 1] 。

这是第三种解决方案。

好了，关于ListView异步加载图片乱序的问题今天我们就讨论到这里，如果你把三种解决方案都理解清楚的话，那么对于这个问题研究的就算比较透彻了。下一篇文章仍然是ListView主题，我们将学习一下如何对ListView控件进行一些功能扩展，感兴趣的朋友请继续阅读 [**Android ListView功能扩展，实现高性能的瀑布流布局**][Android ListView 1] 。

原文链接： [http://blog.csdn.net/guolin\_blog/article/details/45586553][http_blog.csdn.net_guolin_blog_article_details_45586553]

[Android ListView]: http://blog.csdn.net/guolin_blog/article/details/44996879
[view plain]: http://blog.csdn.net/guolin_blog/article/details/45586553#
[Android_OOM]: http://blog.csdn.net/guolin_blog/article/details/9316683
[1439302562_7693.gif]: https://img-my.csdn.net/uploads/201508/11/1439302562_7693.gif
[SouthEast]: /images/20220606/7eb6f88b4f174c83a5b4cb0c64a06cb2.png
[Android]: http://blog.csdn.net/guolin_blog/article/details/9526203
[Android Volley_Volley]: http://blog.csdn.net/guolin_blog/article/details/17482165
[Android Volley_Volley 1]: http://blog.csdn.net/guolin_blog/article/details/17656437
[Android ListView 1]: http://blog.csdn.net/guolin_blog/article/details/46361889
[http_blog.csdn.net_guolin_blog_article_details_45586553]: http://blog.csdn.net/guolin_blog/article/details/45586553