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

时间：2023-03-08 21:49:31

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

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

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

  1. private void loadImage(final String url, final int id) {
  2. handler.post(new Runnable() {
  3. public void run() {
  4. Drawable drawable = null;
  5. try {
  6. drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
  7. } catch (IOException e) {
  8. }
  9. ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
  10. }
  11. });
  12. }

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

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

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

  1. final Handler handler2=new Handler(){
  2. @Override
  3. public void handleMessage(Message msg) {
  4. ((ImageView) LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
  5. }
  6. };

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

  1. // 引入线程池来管理多线程
  2. private void loadImage3(final String url, final int id) {
  3. executorService.submit(new Runnable() {
  4. public void run() {
  5. try {
  6. final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
  7. handler.post(new Runnable() {
  8. public void run() {
  9. ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
  10. }
  11. });
  12. } catch (Exception e) {
  13. throw new RuntimeException(e);
  14. }
  15. }
  16. });
  17. }

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

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

  1. public class AsyncImageLoader3 {
  2. //为了加快速度，在内存中开启缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
  3. public Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();
  4. private ExecutorService executorService = Executors.newFixedThreadPool(5);    //固定五个线程来执行任务
  5. private final Handler handler=new Handler();
  6. /**
  7. *
  8. * @param imageUrl     图像url地址
  9. * @param callback     回调接口
  10. * @return     返回内存中缓存的图像，第一次加载返回null
  11. */
  12. public Drawable loadDrawable(final String imageUrl, final ImageCallback callback) {
  13. //如果缓存过就从缓存中取出数据
  14. if (imageCache.containsKey(imageUrl)) {
  15. SoftReference<Drawable> softReference = imageCache.get(imageUrl);
  16. if (softReference.get() != null) {
  17. return softReference.get();
  18. }
  19. }
  20. //缓存中没有图像，则从网络上取出数据，并将取出的数据缓存到内存中
  21. executorService.submit(new Runnable() {
  22. public void run() {
  23. try {
  24. final Drawable drawable = Drawable.createFromStream(new URL(imageUrl).openStream(), "image.png");
  25. imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
  26. handler.post(new Runnable() {
  27. public void run() {
  28. callback.imageLoaded(drawable);
  29. }
  30. });
  31. } catch (Exception e) {
  32. throw new RuntimeException(e);
  33. }
  34. }
  35. });
  36. return null;
  37. }
  38. //从网络上取数据方法
  39. protected Drawable loadImageFromUrl(String imageUrl) {
  40. try {
  41. return Drawable.createFromStream(new URL(imageUrl).openStream(), "image.png");
  42. } catch (Exception e) {
  43. throw new RuntimeException(e);
  44. }
  45. }
  46. //对外界开放的回调接口
  47. public interface ImageCallback {
  48. //注意 此方法是用来设置目标对象的图像资源
  49. public void imageLoaded(Drawable imageDrawable);
  50. }
  51. }

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

在主线程调用代码：

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

调用异步加载方法：

  1. //引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
  2. private void loadImage4(final String url, final int id) {
  3. //如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
  4. Drawable cacheImage = asyncImageLoader.loadDrawable(url,new AsyncImageLoader.ImageCallback() {
  5. //请参见实现：如果第一次加载url时下面方法会执行
  6. public void imageLoaded(Drawable imageDrawable) {
  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模式而已。代码如下：

  1. public class AsyncImageLoader {
  2. //为了加快速度，加入了缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）
  3. private Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();
  4. /**
  5. *
  6. * @param imageUrl     图像url地址
  7. * @param callback     回调接口
  8. * @return     返回内存中缓存的图像，第一次加载返回null
  9. */
  10. public Drawable loadDrawable(final String imageUrl, final ImageCallback callback) {
  11. //如果缓存过就从缓存中取出数据
  12. if (imageCache.containsKey(imageUrl)) {
  13. SoftReference<Drawable> softReference = imageCache.get(imageUrl);
  14. if (softReference.get() != null) {
  15. return softReference.get();
  16. }
  17. }
  18. final Handler handler = new Handler() {
  19. @Override
  20. public void handleMessage(Message msg) {
  21. callback.imageLoaded((Drawable) msg.obj);
  22. }
  23. };
  24. new Thread() {
  25. public void run() {
  26. Drawable drawable = loadImageFromUrl(imageUrl);
  27. imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
  28. handler.sendMessage(handler.obtainMessage(0, drawable));
  29. }
  30. }.start();
  31. /*
  32. 下面注释的这段代码是Handler的一种代替方法
  33. */
  34. //        new AsyncTask() {
  35. //            @Override
  36. //            protected Drawable doInBackground(Object... objects) {
  37. //                  Drawable drawable = loadImageFromUrl(imageUrl);
  38. //                imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
  39. //                return  drawable;
  40. //            }
  41. //
  42. //            @Override
  43. //            protected void onPostExecute(Object o) {
  44. //                  callback.imageLoaded((Drawable) o);
  45. //            }
  46. //        }.execute();
  47. return null;
  48. }
  49. protected Drawable loadImageFromUrl(String imageUrl) {
  50. try {
  51. return Drawable.createFromStream(new URL(imageUrl).openStream(), "src");
  52. } catch (Exception e) {
  53. throw new RuntimeException(e);
  54. }
  55. }
  56. //对外界开放的回调接口
  57. public interface ImageCallback {
  58. public void imageLoaded(Drawable imageDrawable);
  59. }
  60. }

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

  1. package com.bshark.supertelphone.activity;
  2. import android.app.Activity;
  3. import android.graphics.drawable.Drawable;
  4. import android.os.Bundle;
  5. import android.os.Handler;
  6. import android.os.Message;
  7. import android.widget.ImageView;
  8. import com.bshark.supertelphone.R;
  9. import com.bshark.supertelphone.ui.adapter.util.AsyncImageLoader;
  10. import com.bshark.supertelphone.ui.adapter.util.AsyncImageLoader3;
  11. import java.io.IOException;
  12. import java.net.URL;
  13. import java.util.concurrent.ExecutorService;
  14. import java.util.concurrent.Executors;
  15. public class LazyLoadImageActivity extends Activity {
  16. final Handler handler=new Handler();
  17. final Handler handler2=new Handler(){
  18. @Override
  19. public void handleMessage(Message msg) {
  20. ((ImageView) LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
  21. }
  22. };
  23. private ExecutorService executorService = Executors.newFixedThreadPool(5);    //固定五个线程来执行任务
  24. private AsyncImageLoader asyncImageLoader = new AsyncImageLoader();
  25. private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();
  26. @Override
  27. public void onCreate(Bundle savedInstanceState) {
  28. super.onCreate(savedInstanceState);
  29. setContentView(R.layout.main);
  30. //  loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
  31. //  loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
  32. //  loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
  33. //        loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
  34. //  loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);
  35. loadImage2("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
  36. loadImage2("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
  37. loadImage2("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
  38. loadImage2("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
  39. loadImage2("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);
  40. //        loadImage3("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
  41. //  loadImage3("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
  42. //  loadImage3("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
  43. //        loadImage3("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
  44. //  loadImage3("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);
  45. //        loadImage4("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
  46. //  loadImage4("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
  47. //  loadImage4("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
  48. //        loadImage4("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
  49. //  loadImage4("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);
  50. //        loadImage5("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
  51. //        //为了测试缓存而模拟的网络延时
  52. //        SystemClock.sleep(2000);
  53. //  loadImage5("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
  54. //        SystemClock.sleep(2000);
  55. //  loadImage5("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
  56. //        SystemClock.sleep(2000);
  57. //        loadImage5("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
  58. //        SystemClock.sleep(2000);
  59. //  loadImage5("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);
  60. //        SystemClock.sleep(2000);
  61. //         loadImage5("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
  62. }
  63. @Override
  64. protected void onDestroy() {
  65. executorService.shutdown();
  66. super.onDestroy();
  67. }
  68. //线程加载图像基本原理
  69. private void loadImage(final String url, final int id) {
  70. handler.post(new Runnable() {
  71. public void run() {
  72. Drawable drawable = null;
  73. try {
  74. drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
  75. } catch (IOException e) {
  76. }
  77. ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
  78. }
  79. });
  80. }
  81. //采用handler+Thread模式实现多线程异步加载
  82. private void loadImage2(final String url, final int id) {
  83. Thread thread = new Thread(){
  84. @Override
  85. public void run() {
  86. Drawable drawable = null;
  87. try {
  88. drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
  89. } catch (IOException e) {
  90. }
  91. Message message= handler2.obtainMessage() ;
  92. message.arg1 = id;
  93. message.obj = drawable;
  94. handler2.sendMessage(message);
  95. }
  96. };
  97. thread.start();
  98. thread = null;
  99. }
  100. // 引入线程池来管理多线程
  101. private void loadImage3(final String url, final int id) {
  102. executorService.submit(new Runnable() {
  103. public void run() {
  104. try {
  105. final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
  106. handler.post(new Runnable() {
  107. public void run() {
  108. ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
  109. }
  110. });
  111. } catch (Exception e) {
  112. throw new RuntimeException(e);
  113. }
  114. }
  115. });
  116. }
  117. //引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程
  118. private void loadImage4(final String url, final int id) {
  119. //如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
  120. Drawable cacheImage = asyncImageLoader.loadDrawable(url,new AsyncImageLoader.ImageCallback() {
  121. //请参见实现：如果第一次加载url时下面方法会执行
  122. public void imageLoaded(Drawable imageDrawable) {
  123. ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
  124. }
  125. });
  126. if(cacheImage!=null){
  127. ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
  128. }
  129. }
  130. //采用Handler+Thread+封装外部接口
  131. private void loadImage5(final String url, final int id) {
  132. //如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行
  133. Drawable cacheImage = asyncImageLoader3.loadDrawable(url,new AsyncImageLoader3.ImageCallback() {
  134. //请参见实现：如果第一次加载url时下面方法会执行
  135. public void imageLoaded(Drawable imageDrawable) {
  136. ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
  137. }
  138. });
  139. if(cacheImage!=null){
  140. ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
  141. }
  142. }
  143. }

xml文件大致如下：

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

相关文章