演化理解 Android 异步加载图片

最新推荐文章于 2019-07-16 14:43:00 发布
最新推荐文章于 2019-07-16 14:43:00 发布
阅读量772 收藏
点赞数
文章标签： android layout url thread null exception
 

在学习"Android异步加载图像小结"这篇文章时, 发现有些地方没写清楚，我就根据我的理解，把这篇文章的代码重写整理了一遍，下面就是我的整理。

下面测试使用的layout文件：

简单来说就是 LinearLayout 布局，其下放了5个ImageView:

view plain copy to clipboard print ?
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:orientation="vertical" android:layout_width="fill_parent"  
  4.     android:layout_height="fill_parent">  
  5.     <TextView android:text="图片区域开始" android:id="@+id/textView2"  
  6.         android:layout_width="wrap_content" android:layout_height="wrap_content"></TextView>  
  7.     <ImageView android:id="@+id/imageView1"  
  8.         android:layout_height="wrap_content" android:src="@drawable/icon"  
  9.         android:layout_width="wrap_content"></ImageView>  
  10.     <ImageView android:id="@+id/imageView2"  
  11.         android:layout_height="wrap_content" android:src="@drawable/icon"  
  12.         android:layout_width="wrap_content"></ImageView>  
  13.     <ImageView android:id="@+id/imageView3"  
  14.         android:layout_height="wrap_content" android:src="@drawable/icon"  
  15.         android:layout_width="wrap_content"></ImageView>  
  16.     <ImageView android:id="@+id/imageView4"  
  17.         android:layout_height="wrap_content" android:src="@drawable/icon"  
  18.         android:layout_width="wrap_content"></ImageView>  
  19.     <ImageView android:id="@+id/imageView5"  
  20.         android:layout_height="wrap_content" android:src="@drawable/icon"  
  21.         android:layout_width="wrap_content"></ImageView>  
  22.     <TextView android:text="图片区域结束" android:id="@+id/textView1"  
  23.         android:layout_width="wrap_content" android:layout_height="wrap_content"></TextView>  
  24. </LinearLayout>  


我们将演示的逻辑是异步从服务器上下载5张不同图片，依次放入这5个ImageView。上下2个TextView 是为了方便我们看是否阻塞了UI的显示。


当然 AndroidManifest.xml 文件中要配置好网络访问权限。

<uses-permission android:name="android.permission.INTERNET"></uses-permission>

Handler+Runnable模式

我们先看一个并不是异步线程加载的例子，使用 Handler+Runnable模式。

这里为何不是新开线程的原因请参看这篇文章：Android Runnable 运行在那个线程 这里的代码其实是在UI 主线程中下载图片的，而不是新开线程。

我们运行下面代码时，会发现他其实是阻塞了整个界面的显示，需要所有图片都加载完成后，才能显示界面。

view plain copy to clipboard print ?
  1. package ghj1976.AndroidTest;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.URL;  
  5. import android.app.Activity;  
  6. import android.graphics.drawable.Drawable;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.SystemClock;  
  10. import android.util.Log;  
  11. import android.widget.ImageView;  
  12.   
  13. public class MainActivity extends Activity {  
  14.     @Override  
  15.     public void onCreate(Bundle savedInstanceState) {  
  16.         super.onCreate(savedInstanceState);  
  17.         setContentView(R.layout.main);  
  18.         loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);  
  19.         loadImage(http://www.chinatelecom.com.cn/images/logo_new.gif",   
  20.                 R.id.imageView2);  
  21.         loadImage("http://cache.soso.com/30d/img/web/logo.gif, R.id.imageView3);   
  22.         loadImage("http://csdnimg.cn/www/images/csdnindex_logo.gif",  
  23.                 R.id.imageView4);  
  24.         loadImage("http://images.cnblogs.com/logo_small.gif",  
  25.                 R.id.imageView5);  
  26.     }  
  27.   
  28.     private Handler handler = new Handler();  
  29.   
  30.     private void loadImage(final String url, final int id) {  
  31.         handler.post(new Runnable() {  
  32.             public void run() {  
  33.                 Drawable drawable = null;  
  34.                 try {  
  35.                     drawable = Drawable.createFromStream(  
  36.                             new URL(url).openStream(), "image.gif");  
  37.                 } catch (IOException e) {  
  38.                     Log.d("test", e.getMessage());  
  39.                 }  
  40.                 if (drawable == null) {  
  41.                     Log.d("test", "null drawable");  
  42.                 } else {  
  43.                     Log.d("test", "not null drawable");  
  44.                 }  
  45.                                 // 为了测试缓存而模拟的网络延时    
  46.   
  47.                                 SystemClock.sleep(2000);   
  48.   
  49.                 ((ImageView) MainActivity.this.findViewById(id))  
  50.                         .setImageDrawable(drawable);  
  51.             }  
  52.         });  
  53.     }  
  54. }  

Handler+Thread+Message模式

这种模式使用了线程，所以可以看到异步加载的效果。

核心代码：

view plain copy to clipboard print ?
  1. package ghj1976.AndroidTest;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.URL;  
  5. import android.app.Activity;  
  6. import android.graphics.drawable.Drawable;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.Message;  
  10. import android.os.SystemClock;  
  11. import android.util.Log;  
  12. import android.widget.ImageView;  
  13.   
  14. public class MainActivity extends Activity {  
  15.     @Override  
  16.     public void onCreate(Bundle savedInstanceState) {  
  17.         super.onCreate(savedInstanceState);  
  18.         setContentView(R.layout.main);  
  19.         loadImage2("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);  
  20.         loadImage2("http://www.chinatelecom.com.cn/images/logo_new.gif",  
  21.                 R.id.imageView2);  
  22.         loadImage2("http://cache.soso.com/30d/img/web/logo.gif", R.id.imageView3);  
  23.         loadImage2("http://csdnimg.cn/www/images/csdnindex_logo.gif",  
  24.                 R.id.imageView4);  
  25.         loadImage2("http://images.cnblogs.com/logo_small.gif",  
  26.                 R.id.imageView5);  
  27.     }  
  28.   
  29.     final Handler handler2 = new Handler() {  
  30.         @Override  
  31.         public void handleMessage(Message msg) {  
  32.             ((ImageView) MainActivity.this.findViewById(msg.arg1))  
  33.                     .setImageDrawable((Drawable) msg.obj);  
  34.         }  
  35.     };  
  36.   
  37.     // 采用handler+Thread模式实现多线程异步加载   
  38.     private void loadImage2(final String url, final int id) {  
  39.         Thread thread = new Thread() {  
  40.             @Override  
  41.             public void run() {  
  42.                 Drawable drawable = null;  
  43.                 try {  
  44.                     drawable = Drawable.createFromStream(  
  45.                             new URL(url).openStream(), "image.png");  
  46.                 } catch (IOException e) {  
  47.                     Log.d("test", e.getMessage());  
  48.                 }  
  49.   
  50.                 // 模拟网络延时   
  51.                 SystemClock.sleep(2000);  
  52.   
  53.                 Message message = handler2.obtainMessage();  
  54.                 message.arg1 = id;  
  55.                 message.obj = drawable;  
  56.                 handler2.sendMessage(message);  
  57.             }  
  58.         };  
  59.         thread.start();  
  60.         thread = null;  
  61.     }  
  62.   
  63. }  


这时候我们可以看到实现了异步加载， 界面打开时，五个ImageView都是没有图的，然后在各自线程下载完后才把图自动更新上去。

Handler+ExecutorService(线程池)+MessageQueue模式

能开线程的个数毕竟是有限的，我们总不能开很多线程，对于手机更是如此。

这个例子是使用线程池。Android拥有与Java相同的ExecutorService实现，我们就来用它。

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

线程池的信息可以参看这篇文章：Java&Android的线程池－ExecutorService 下面的演示例子是创建一个可重用固定线程数的线程池。

核心代码

view plain copy to clipboard print ?
  1. package ghj1976.AndroidTest;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.URL;  
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7.   
  8. import android.app.Activity;  
  9. import android.graphics.drawable.Drawable;  
  10. import android.os.Bundle;  
  11. import android.os.Handler;  
  12. import android.os.Message;  
  13. import android.os.SystemClock;  
  14. import android.util.Log;  
  15. import android.widget.ImageView;  
  16.   
  17. public class MainActivity extends Activity {  
  18.     @Override  
  19.     public void onCreate(Bundle savedInstanceState) {  
  20.         super.onCreate(savedInstanceState);  
  21.         setContentView(R.layout.main);  
  22.         loadImage3("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);  
  23.         loadImage3("http://www.chinatelecom.com.cn/images/logo_new.gif",  
  24.                 R.id.imageView2);  
  25.         loadImage3("http://cache.soso.com/30d/img/web/logo.gif",  
  26.                 R.id.imageView3);  
  27.         loadImage3("http://csdnimg.cn/www/images/csdnindex_logo.gif",  
  28.                 R.id.imageView4);  
  29.         loadImage3("http://images.cnblogs.com/logo_small.gif",  
  30.                 R.id.imageView5);  
  31.     }  
  32.   
  33.     private Handler handler = new Handler();  
  34.   
  35.     private ExecutorService executorService = Executors.newFixedThreadPool(5);  
  36.   
  37.     // 引入线程池来管理多线程   
  38.     private void loadImage3(final String url, final int id) {  
  39.         executorService.submit(new Runnable() {  
  40.             public void run() {  
  41.                 try {  
  42.                     final Drawable drawable = Drawable.createFromStream(  
  43.                             new URL(url).openStream(), "image.png");  
  44.                     // 模拟网络延时   
  45.                     SystemClock.sleep(2000);  
  46.                     handler.post(new Runnable() {  
  47.                         public void run() {  
  48.                             ((ImageView) MainActivity.this.findViewById(id))  
  49.                                     .setImageDrawable(drawable);  
  50.                         }  
  51.                     });  
  52.                 } catch (Exception e) {  
  53.                     throw new RuntimeException(e);  
  54.                 }  
  55.             }  
  56.         });  
  57.     }  
  58. }  


这里我们象第一步一样使用了 handler.post(new Runnable() {  更新前段显示当然是在UI主线程，我们还有 executorService.submit(new Runnable() { 来确保下载是在线程池的线程中。

Handler+ExecutorService(线程池)+MessageQueue+缓存模式

下面比起前一个做了几个改造:

  • 把整个代码封装在一个类中
  • 为了避免出现同时多次下载同一幅图的问题,使用了本地缓存

封装的类:

view plain copy to clipboard print ?
  1. package ghj1976.AndroidTest;  
  2.   
  3. import java.lang.ref.SoftReference;  
  4. import java.net.URL;  
  5. import java.util.HashMap;  
  6. import java.util.Map;  
  7. import java.util.concurrent.ExecutorService;  
  8. import java.util.concurrent.Executors;  
  9.   
  10. import android.graphics.drawable.Drawable;  
  11. import android.os.Handler;  
  12. import android.os.SystemClock;  
  13.   
  14. public class AsyncImageLoader3 {  
  15.     // 为了加快速度，在内存中开启缓存（主要应用于重复图片较多时，或者同一个图片要多次被访问，比如在ListView时来回滚动）   
  16.     public Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();  
  17.       
  18.     private ExecutorService executorService = Executors.newFixedThreadPool(5); // 固定五个线程来执行任务   
  19.     private final Handler handler = new Handler();  
  20.   
  21.     /** 
  22.      *  
  23.      * @param imageUrl 
  24.      *            图像url地址 
  25.      * @param callback 
  26.      *            回调接口 
  27.      * @return 返回内存中缓存的图像，第一次加载返回null 
  28.      */  
  29.     public Drawable loadDrawable(final String imageUrl,  
  30.             final ImageCallback callback) {  
  31.         // 如果缓存过就从缓存中取出数据   
  32.         if (imageCache.containsKey(imageUrl)) {  
  33.             SoftReference<Drawable> softReference = imageCache.get(imageUrl);  
  34.             if (softReference.get() != null) {  
  35.                 return softReference.get();  
  36.             }  
  37.         }  
  38.         // 缓存中没有图像，则从网络上取出数据，并将取出的数据缓存到内存中   
  39.         executorService.submit(new Runnable() {  
  40.             public void run() {  
  41.                 try {  
  42.                     final Drawable drawable = loadImageFromUrl(imageUrl);   
  43.                           
  44.                     imageCache.put(imageUrl, new SoftReference<Drawable>(  
  45.                             drawable));  
  46.   
  47.                     handler.post(new Runnable() {  
  48.                         public void run() {  
  49.                             callback.imageLoaded(drawable);  
  50.                         }  
  51.                     });  
  52.                 } catch (Exception e) {  
  53.                     throw new RuntimeException(e);  
  54.                 }  
  55.             }  
  56.         });  
  57.         return null;  
  58.     }  
  59.   
  60.     // 从网络上取数据方法   
  61.     protected Drawable loadImageFromUrl(String imageUrl) {  
  62.         try {  
  63.             // 测试时，模拟网络延时，实际时这行代码不能有   
  64.             SystemClock.sleep(2000);  
  65.   
  66.             return Drawable.createFromStream(new URL(imageUrl).openStream(),  
  67.                     "image.png");  
  68.   
  69.         } catch (Exception e) {  
  70.             throw new RuntimeException(e);  
  71.         }  
  72.     }  
  73.   
  74.     // 对外界开放的回调接口   
  75.     public interface ImageCallback {  
  76.         // 注意 此方法是用来设置目标对象的图像资源   
  77.         public void imageLoaded(Drawable imageDrawable);  
  78.     }  
  79. }  


说明：

final参数是指当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。参看：Java关键字final、static使用总结
这里使用SoftReference 是为了解决内存不足的错误（OutOfMemoryError）的，更详细的可以参看：内存优化的两个类:SoftReference 和 WeakReference

前段调用:

view plain copy to clipboard print ?
  1. package ghj1976.AndroidTest;  
  2.   
  3. import android.app.Activity;  
  4. import android.graphics.drawable.Drawable;  
  5. import android.os.Bundle;  
  6.   
  7. import android.widget.ImageView;  
  8.   
  9. public class MainActivity extends Activity {  
  10.     @Override  
  11.     public void onCreate(Bundle savedInstanceState) {  
  12.         super.onCreate(savedInstanceState);  
  13.         setContentView(R.layout.main);  
  14.         loadImage4("http://www.baidu.com/img/baidu_logo.gif", R.id.imageView1);  
  15.         loadImage4("http://www.chinatelecom.com.cn/images/logo_new.gif",  
  16.                 R.id.imageView2);  
  17.         loadImage4("http://cache.soso.com/30d/img/web/logo.gif",  
  18.                 R.id.imageView3);  
  19.         loadImage4("http://csdnimg.cn/www/images/csdnindex_logo.gif",  
  20.                 R.id.imageView4);  
  21.         loadImage4("http://images.cnblogs.com/logo_small.gif",  
  22.                 R.id.imageView5);  
  23.     }  
  24.   
  25.     private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();  
  26.   
  27.     // 引入线程池，并引入内存缓存功能,并对外部调用封装了接口，简化调用过程   
  28.     private void loadImage4(final String url, final int id) {  
  29.         // 如果缓存过就会从缓存中取出图像，ImageCallback接口中方法也不会被执行   
  30.         Drawable cacheImage = asyncImageLoader3.loadDrawable(url,  
  31.                 new AsyncImageLoader3.ImageCallback() {  
  32.                     // 请参见实现：如果第一次加载url时下面方法会执行   
  33.                     public void imageLoaded(Drawable imageDrawable) {  
  34.                         ((ImageView) findViewById(id))  
  35.                                 .setImageDrawable(imageDrawable);  
  36.                     }  
  37.                 });  
  38.         if (cacheImage != null) {  
  39.             ((ImageView) findViewById(id)).setImageDrawable(cacheImage);  
  40.         }  
  41.     }  
  42.   
  43. }  

job_dinge
关注
android中的异步加载
Blue的博客
09-05 589
众所周知Android应用开发中不能在UI线程中做耗时的操作，否则就会弹出烦人的ANR窗口。 应用开发中如果需要加载来自网络、磁盘或其他非内存中图片资源时，因加载时间会受到其他因素（如磁盘、网络、图片大小、CPU等等）的影响，很容易产生耗时操作。所以在进行类似操作时要避免在UI线程中进行。今天就和大家分享一下如何通过AsyncTask异步加载图片和怎么处理多线程并发问题 我相信对于初学
Android 异步加载解决方案
04-09
NULL 博文链接：https://jgeng.iteye.com/blog/1630650
Android 异步加载
01-23 154
Android 4.0 后 貌似规定了 在主线程中不允许访问网络，在子线程中不允许修改UI. 否则会抛出NetworkOnMainThreadException 异常 解决办法：采用继承AsyncTask<String, String, String>实现AsyncTask中定义的几个方法 onPreExecute() doInBackground(Params.....
android异步加载
DreamCarMustang
05-29 4237
本篇博客总结了慕课网关于异步加载图片的知识要点，和大家一起分享，有感觉听得不连贯的可以来看看。 看完本篇博客，你将学习到下面的知识： 1.怎样将一个url（也可以说是一个InputStream）转换为一个json字符串信息。 2.怎样运用插件写一个我认为完美的model类来为解析json做准备。 3.AsyncTask的基本用法。 4.Gosn的基本用法。 5.Adapter的常用优化
Android异步加载
weixin_30642267的博客
07-16 158
异步任务AsyncTask注意事项： 必须在UI线程中创建AsyncTask的实例。 必须载UI线程中调用AsyncTask的execute()方法。 重写的四个方法是系统自动调用的，不应手动调用。doInBackground()、onProgressUpdate()、 每个AsyncTask只能被执行一次，多次调用将会引发异常。 　　doInBackground()方法是运行...
Android演化理解 Android 异步加载图片.zip源码资源下载
02-23
这个"Android演化理解 Android 异步加载图片.zip"源码资源提供了对Android平台图片加载机制演进的理解和实现方法。以下是这个主题涵盖的一些关键知识点： 1. UI线程与工作线程：Android系统的主线程（UI线程）负责...
Android演化理解 Android 异步加载图片.rar
12-03
在深入理解Android异步加载图片的过程中，还需要掌握Bitmap类的使用和内存管理。Bitmap对象占用了大量的内存，不当使用可能导致内存泄漏或内存抖动。因此，需要合理地配置Bitmap的配置参数，如Bitmap.Config，以及...
Android演化理解 Android 异步加载图片.zip
12-04
这个"Android演化理解 Android 异步加载图片"的压缩包文件提供了关于如何在Android平台处理图片加载的源码参考，这对于开发者来说是极其宝贵的资源。 首先，我们要了解为什么需要异步加载图片。在移动设备上，内存...
Android程序研发源码演化理解 Android 异步加载图片.zip
04-30
下面将详细探讨Android异步加载图片的原理、方法和最佳实践。 1. **异步加载图片的重要性**： - 用户体验：避免因图片加载导致的UI卡顿，提高应用响应速度。 - 资源优化：减少内存占用，防止OOM（OutOfMemory）...
android异步加载服务器数据
01-07
功能：1、从服务器获取数据；2、异步加载；3、显示 参考：https://www.jianshu.com/p/16942fbd50f3
Android异步加载（一）
cheche8337的博客
12-01 361
1.Android异步加载：顾名思义用异步的方式加载数据； 2.为什么要用异步加载：Android单线程模型；还有就是耗时操作阻塞UI线程。 3.实现异步加载的俩种方式：多线程\线程池；AsyncTask（底层也是多线程）。
Android异步加载（UI刷新）
黑马小杰的博客
06-01 6199
指切正题，为何要选择异步加载？ 由于UI线程（也可叫主线程）负责处理用户输入事件（TP事件，显示事件等），直接与用户交互，如果UI线程阻塞，直接会影响用户的体验效果，严重的会报ANR错误。所以我们需要把耗时操作移出主线程，在子线程中进行处理。 下面罗列几种实现异步加载的方式。 传统JAVA方法实现异步 1.继承Thread类 代码如下 package UseThred; pu...
Android开发--异步加载
weixin_33910434的博客
10-06 224
因为移动端软件开发思维模式或者说是开发的架构其实是不分平台和编程语言的，就拿安卓和IOS来说，他们都是移动前端app开发展示数据和用户交互数据的数据终端，移动架构的几个大模块：UI界面展示、本地数据可持续化存储、网络数据请求、性能优化等等，安卓和IOS开发都要考虑这些架构的模块。所以，熟悉IOS的开发的人，再去学习一下安卓的开发以及安卓的开发模式，你会发现很多技术和思想安卓和IOS是一样的，只是可...
android的异步加载与UI
sumakira的专栏
03-02 6381
原帖地址： http://blog.163.com/freemanls@126/blog/static/16458506120117702029517/ android的异步加载与UI   2011-08-07 12:55:27|  分类： Android |  标签：android  异步  图片   |字号 订阅
安卓Android源码演化：理解异步加载图片技术
资源摘要信息:"安卓Android源码——演化理解异步加载图片.zip" 安卓（Android）是谷歌开发的一个基于Linux内核的开源操作系统，广泛用于智能手机和平板电脑等移动设备。由于其开放性和灵活性，开发者能够自由地访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值