Android异步加载图像（含线程池，缓存方法）

研究了android从网络上异步加载图像：

（1）由于android UI更新支持单一线程原则，所以从网络上取数据并更新到界面上，为了不阻塞主线程首先可能会想到以下方法。

在主线程中new 一个Handler对象，加载图像方法如下所示

[java] view plain copy print ?

1. privatevoidloadImage(finalStringurl,finalintid){
2. handler.post(newRunnable(){
3. publicvoidrun(){
4. Drawabledrawable=null;
5. try{
6. drawable=Drawable.createFromStream(newURL(url).openStream(),"image.png");
7. }catch(IOExceptione){
8. }
9. ((ImageView)LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
10. }
11. });
12. }

上面这个方法缺点很显然，经测试，如果要加载多个图片，这并不能实现异步加载，而是等到所有的图片都加载完才一起显示，因为它们都运行在一个线程中。

然后，我们可以简单改进下，将Handler+Runnable模式改为Handler+Thread+Message模式不就能实现同时开启多个线程吗？

（2）在主线程中new 一个Handler对象，代码如下：

[java] view plain copy print ?

1. finalHandlerhandler2=newHandler(){
2. @Override
3. publicvoidhandleMessage(Messagemsg){
4. ((ImageView)LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
5. }
6. };

对应加载图像代码如下：对应加载图像代码如下：对应加载图像代码如下：

[java] view plain copy print ?

1. //引入线程池来管理多线程
2. privatevoidloadImage3(finalStringurl,finalintid){
3. executorService.submit(newRunnable(){
4. publicvoidrun(){
5. try{
6. finalDrawabledrawable=Drawable.createFromStream(newURL(url).openStream(),"image.png");
7. handler.post(newRunnable(){
9. publicvoidrun(){
10. ((ImageView)LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
11. }
12. });
13. }catch(Exceptione){
14. thrownewRuntimeException(e);
15. }
16. }
17. });
18. }

（4）为了更方便使用我们可以将异步加载图像方法封装一个类，对外界只暴露一个方法即可，考虑到效率问题我们可以引入内存缓存机制，做法是

建立一个HashMap，其键（key）为加载图像url，其值（value）是图像对象Drawable。先看一下我们封装的类

[java] view plain copy print ?

1. publicclassAsyncImageLoader3{
2. //为了加快速度，在内存中开启缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
3. publicMap<String,SoftReference<Drawable>>imageCache=newHashMap<String,SoftReference<Drawable>>();
4. privateExecutorServiceexecutorService=Executors.newFixedThreadPool(5);//固定五个线程来执行任务
5. privatefinalHandlerhandler=newHandler();
7. /**
8. *
9. *@paramimageUrl图像url地址
10. *@paramcallback回调接口
11. *@return返回内存中缓存的图像，第一次加载返回null
12. */
13. publicDrawableloadDrawable(finalStringimageUrl,finalImageCallbackcallback){
14. //如果缓存过就从缓存中取出数据
15. if(imageCache.containsKey(imageUrl)){
16. SoftReference<Drawable>softReference=imageCache.get(imageUrl);
17. if(softReference.get()!=null){
18. returnsoftReference.get();
19. }
20. }
21. //缓存中没有图像，则从网络上取出数据，并将取出的数据缓存到内存中
22. executorService.submit(newRunnable(){
23. publicvoidrun(){
24. try{
25. finalDrawabledrawable=Drawable.createFromStream(newURL(imageUrl).openStream(),"image.png");
27. imageCache.put(imageUrl,newSoftReference<Drawable>(drawable));
29. handler.post(newRunnable(){
30. publicvoidrun(){
31. callback.imageLoaded(drawable);
32. }
33. });
34. }catch(Exceptione){
35. thrownewRuntimeException(e);
36. }
37. }
38. });
39. returnnull;
40. }
41. //从网络上取数据方法
42. protectedDrawableloadImageFromUrl(StringimageUrl){
43. try{
44. returnDrawable.createFromStream(newURL(imageUrl).openStream(),"image.png");
45. }catch(Exceptione){
46. thrownewRuntimeException(e);
47. }
48. }
49. //对外界开放的回调接口
50. publicinterfaceImageCallback{
51. //注意此方法是用来设置目标对象的图像资源
52. publicvoidimageLoaded(DrawableimageDrawable);
53. }
54. }

这样封装好后使用起来就方便多了。在主线程中首先要引入AsyncImageLoader3 对象，然后直接调用其loadDrawable方法即可，需要注意的是ImageCallback接口的imageLoaded方法是唯一可以把加载的图像设置到目标ImageView或其相关的组件上。

在主线程调用代码：

先实例化对象 private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();

调用异步加载方法：

[java] view plain copy print ?

1. //引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
2. privatevoidloadImage4(finalStringurl,finalintid){
3. //如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
4. DrawablecacheImage=asyncImageLoader.loadDrawable(url,newAsyncImageLoader.ImageCallback(){
5. //请参见实现：如果第一次加载url时下面方法会执行
6. publicvoidimageLoaded(DrawableimageDrawable){
7. ((ImageView)findViewById(id)).setImageDrawable(imageDrawable);
8. }
9. });
10. if(cacheImage!=null){
11. ((ImageView)findViewById(id)).setImageDrawable(cacheImage);
12. }
13. }

5）同理，下面也给出采用Thread+Handler+MessageQueue+内存缓存代码，原则同（4），只是把线程池换成了Thread+Handler+MessageQueue模式而已。代码如下：5）同理，下面也给出采用Thread+Handler+MessageQueue+内存缓存代码，原则同（4），只是把线程池换成了Thread+Handler+MessageQueue模式而已。代码如下：

[java] view plain copy print ?

1. publicclassAsyncImageLoader{
2. //为了加快速度，加入了缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
3. privateMap<String,SoftReference<Drawable>>imageCache=newHashMap<String,SoftReference<Drawable>>();
5. /**
6. *
7. *@paramimageUrl图像url地址
8. *@paramcallback回调接口
9. *@return返回内存中缓存的图像，第一次加载返回null
10. */
11. publicDrawableloadDrawable(finalStringimageUrl,finalImageCallbackcallback){
12. //如果缓存过就从缓存中取出数据
13. if(imageCache.containsKey(imageUrl)){
14. SoftReference<Drawable>softReference=imageCache.get(imageUrl);
15. if(softReference.get()!=null){
16. returnsoftReference.get();
17. }
18. }
20. finalHandlerhandler=newHandler(){
21. @Override
22. publicvoidhandleMessage(Messagemsg){
23. callback.imageLoaded((Drawable)msg.obj);
24. }
25. };
26. newThread(){
27. publicvoidrun(){
28. Drawabledrawable=loadImageFromUrl(imageUrl);
29. imageCache.put(imageUrl,newSoftReference<Drawable>(drawable));
30. handler.sendMessage(handler.obtainMessage(0,drawable));
32. }
34. }.start();
35. /*
36. 下面注释的这段代码是Handler的一种代替方法
37. */
38. //newAsyncTask(){
39. //@Override
40. //protectedDrawabledoInBackground(Object...objects){
41. //Drawabledrawable=loadImageFromUrl(imageUrl);
42. //imageCache.put(imageUrl,newSoftReference<Drawable>(drawable));
43. //returndrawable;
44. //}
45. //
46. //@Override
47. //protectedvoidonPostExecute(Objecto){
48. //callback.imageLoaded((Drawable)o);
49. //}
50. //}.execute();
51. returnnull;
52. }
54. protectedDrawableloadImageFromUrl(StringimageUrl){
55. try{
56. returnDrawable.createFromStream(newURL(imageUrl).openStream(),"src");
57. }catch(Exceptione){
58. thrownewRuntimeException(e);
59. }
60. }
61. //对外界开放的回调接口
62. publicinterfaceImageCallback{
63. publicvoidimageLoaded(DrawableimageDrawable);
64. }
65. }

至此，异步加载就介绍完了，下面给出的代码为测试用的完整代码：

[java] view plain copy print ?

1. packagecom.bshark.supertelphone.activity;
3. importandroid.app.Activity;
4. importandroid.graphics.drawable.Drawable;
5. importandroid.os.Bundle;
6. importandroid.os.Handler;
7. importandroid.os.Message;
8. importandroid.widget.ImageView;
9. importcom.bshark.supertelphone.R;
10. importcom.bshark.supertelphone.ui.adapter.util.AsyncImageLoader;
11. importcom.bshark.supertelphone.ui.adapter.util.AsyncImageLoader3;
13. importjava.io.IOException;
14. importjava.net.URL;
15. importjava.util.concurrent.ExecutorService;
16. importjava.util.concurrent.Executors;
18. publicclassLazyLoadImageActivityextendsActivity{
19. finalHandlerhandler=newHandler();
20. finalHandlerhandler2=newHandler(){
21. @Override
22. publicvoidhandleMessage(Messagemsg){
23. ((ImageView)LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
24. }
25. };
26. privateExecutorServiceexecutorService=Executors.newFixedThreadPool(5);//固定五个线程来执行任务
27. privateAsyncImageLoaderasyncImageLoader=newAsyncImageLoader();
28. privateAsyncImageLoader3asyncImageLoader3=newAsyncImageLoader3();
31. @Override
32. publicvoidonCreate(BundlesavedInstanceState){
33. super.onCreate(savedInstanceState);
34. setContentView(R.layout.main);
36. //loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.image1);
37. //loadImage("http://www.baidu.com/img/baidu_logo.gif",R.id.image2);
38. //loadImage("http://cache.soso.com/30d/img/web/logo.gif",R.id.image3);
39. //loadImage("http://www.baidu.com/img/baidu_logo.gif",R.id.image4);
40. //loadImage("http://cache.soso.com/30d/img/web/logo.gif",R.id.image5);
42. loadImage2("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.image1);
43. loadImage2("http://www.baidu.com/img/baidu_logo.gif",R.id.image2);
44. loadImage2("http://cache.soso.com/30d/img/web/logo.gif",R.id.image3);
45. loadImage2("http://www.baidu.com/img/baidu_logo.gif",R.id.image4);
46. loadImage2("http://cache.soso.com/30d/img/web/logo.gif",R.id.image5);
47. //loadImage3("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.image1);
48. //loadImage3("http://www.baidu.com/img/baidu_logo.gif",R.id.image2);
49. //loadImage3("http://cache.soso.com/30d/img/web/logo.gif",R.id.image3);
50. //loadImage3("http://www.baidu.com/img/baidu_logo.gif",R.id.image4);
51. //loadImage3("http://cache.soso.com/30d/img/web/logo.gif",R.id.image5);
53. //loadImage4("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.image1);
54. //loadImage4("http://www.baidu.com/img/baidu_logo.gif",R.id.image2);
55. //loadImage4("http://cache.soso.com/30d/img/web/logo.gif",R.id.image3);
56. //loadImage4("http://www.baidu.com/img/baidu_logo.gif",R.id.image4);
57. //loadImage4("http://cache.soso.com/30d/img/web/logo.gif",R.id.image5);
59. //loadImage5("http://www.chinatelecom.com.cn/images/logo_new.gif",R.id.image1);
60. ////为了测试缓存而模拟的网络延时
61. //SystemClock.sleep(2000);
62. //loadImage5("http://www.baidu.com/img/baidu_logo.gif",R.id.image2);
63. //SystemClock.sleep(2000);
64. //loadImage5("http://cache.soso.com/30d/img/web/logo.gif",R.id.image3);
65. //SystemClock.sleep(2000);
66. //loadImage5("http://www.baidu.com/img/baidu_logo.gif",R.id.image4);
67. //SystemClock.sleep(2000);
68. //loadImage5("http://cache.soso.com/30d/img/web/logo.gif",R.id.image5);
69. //SystemClock.sleep(2000);
70. //loadImage5("http://www.baidu.com/img/baidu_logo.gif",R.id.image4);
71. }
73. @Override
74. protectedvoidonDestroy(){
75. executorService.shutdown();
76. super.onDestroy();
77. }
78. //线程加载图像基本原理
79. privatevoidloadImage(finalStringurl,finalintid){
80. handler.post(newRunnable(){
81. publicvoidrun(){
82. Drawabledrawable=null;
83. try{
84. drawable=Drawable.createFromStream(newURL(url).openStream(),"image.png");
85. }catch(IOExceptione){
86. }
87. ((ImageView)LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
88. }
89. });
90. }
91. //采用handler+Thread模式实现多线程异步加载
92. privatevoidloadImage2(finalStringurl,finalintid){
93. Threadthread=newThread(){
94. @Override
95. publicvoidrun(){
96. Drawabledrawable=null;
97. try{
98. drawable=Drawable.createFromStream(newURL(url).openStream(),"image.png");
99. }catch(IOExceptione){
100. }
102. Messagemessage=handler2.obtainMessage();
103. message.arg1=id;
104. message.obj=drawable;
105. handler2.sendMessage(message);
106. }
107. };
108. thread.start();
109. thread=null;
110. }
111. //引入线程池来管理多线程
112. privatevoidloadImage3(finalStringurl,finalintid){
113. executorService.submit(newRunnable(){
114. publicvoidrun(){
115. try{
116. finalDrawabledrawable=Drawable.createFromStream(newURL(url).openStream(),"image.png");
117. handler.post(newRunnable(){
119. publicvoidrun(){
120. ((ImageView)LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
121. }
122. });
123. }catch(Exceptione){
124. thrownewRuntimeException(e);
125. }
126. }
127. });
128. }
129. //引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
130. privatevoidloadImage4(finalStringurl,finalintid){
131. //如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
132. DrawablecacheImage=asyncImageLoader.loadDrawable(url,newAsyncImageLoader.ImageCallback(){
133. //请参见实现：如果第一次加载url时下面方法会执行
134. publicvoidimageLoaded(DrawableimageDrawable){
135. ((ImageView)findViewById(id)).setImageDrawable(imageDrawable);
136. }
137. });
138. if(cacheImage!=null){
139. ((ImageView)findViewById(id)).setImageDrawable(cacheImage);
140. }
141. }
143. //采用Handler+Thread+封装外部接口
144. privatevoidloadImage5(finalStringurl,finalintid){
145. //如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
146. DrawablecacheImage=asyncImageLoader3.loadDrawable(url,newAsyncImageLoader3.ImageCallback(){
147. //请参见实现：如果第一次加载url时下面方法会执行
148. publicvoidimageLoaded(DrawableimageDrawable){
149. ((ImageView)findViewById(id)).setImageDrawable(imageDrawable);
150. }
151. });
152. if(cacheImage!=null){
153. ((ImageView)findViewById(id)).setImageDrawable(cacheImage);
154. }
155. }
158. }

xml文件大致如下：

[html] view plain copy print ?

1. <?xmlversion="1.0"encoding="utf-8"?>
3. <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
4. android:layout_width="fill_parent"
5. android:orientation="vertical"
6. android:layout_height="fill_parent">
7. <ImageViewandroid:id="@+id/image1"android:layout_height="wrap_content"android:layout_width="fill_parent"></ImageView>
8. <ImageViewandroid:id="@+id/image2"android:layout_height="wrap_content"android:layout_width="fill_parent"></ImageView>
9. <ImageViewandroid:id="@+id/image3"android:layout_height="wrap_content"android:layout_width="fill_parent"></ImageView>
10. <ImageViewandroid:id="@+id/image5"android:layout_height="wrap_content"android:layout_width="fill_parent"></ImageView>
11. <ImageViewandroid:id="@+id/image4"android:layout_height="wrap_content"android:layout_width="fill_parent"></ImageView>
12. </LinearLayout>

更多相关文章

1. Android热修复三部曲之动态加载补丁.dex文件
2. Android练手小项目（KTReader）基于mvp架构（三）
3. 初窥图像处理利器RenderScript
4. Android(安卓)最火的快速开发框架XUtils
5. Android开发 Handler+ExecutorService(线程池)+MessageQueue模式
6. android横竖屏 用法总结
7. webView 的深入研究
8. Android下利用zbar类库实现扫一扫
9. 【异步加载】Android(安卓)网络数据异步加载解决方案

随机推荐

1. 【译文】通过 android:ssp 高效过滤 Andr
2. Android访问服务器出现W/System.err(9302
3. Android(安卓)& Chrome
4. Android(安卓)ANR问题分析
5. Android七大布局
6. listview使用小技巧
7. ROS与Android的通信
8. java/android 统计文件夹大小及删除文件
9. Android 登录界面Demo源码
10. android在代码中为new出的控件设置ID及se