利用多线程提高程序性能（for Android）

三里屯摇滚

利用多线程提高程序性能（for Android）


要想搞出一个反应迅速的Android应用程序，一个很好的做法就是确保在主UI线程里执行尽量少的代码。任何有可能花费较长时间来执行的代码如果在主UI线程执行，则会让程序挂起无法响应用户的操作，所以应该放到一个单独的线程里执行。典型的例子就是与网络通信相关的操作了，因为通过网络收发信息的快慢我们无法预测，有可能“biu”地一下就搞定了，也有可能磨磨唧唧半天。用户心情好的话可能会容忍一点点迟延，而且前提是你给出了必要的提示，但是一个看上去根本不动貌似嗝儿屁的程序……（译注：就好比Ajax技术出现之前的网页，用户可以习惯短时间的载入，但是一个载入了半天都是空白的浏览器窗口就常常让那个拨号时代的我们感到困惑和抓狂。）
在这篇文章中，我们将创建一个简单的图片下载程序来演示一下多线程模式。我们将从网上下载一坨图片，然后用这些图片生成一个缩略图列表。创建一个异步工作的任务，让它在后台下载图片，会让我们的程序看上去更快。（译注：这里我加上“看上去”，因为我认为所谓多线程让程序更快，更多的意义在于“提高对用户操作的响应”。包括本文题目，所谓的“高性能”，主要指的还是避免UI的硬直（格斗游戏术语，请自行google）、挂起。毕竟多线程无法避免代码固有的主要资源开销。）

一个图片下载器

从web下载图片很简单，使用SDK提供的HTTP相关的类即可实现。下面是一个简单的实现。
(译注：下面用到的AndroidHttpClient等类从2.2版，也就是API Level 8才开始提供。请2.1以下各位从代码领会精神即可。直接用HttpClient应该亦可实现。)

1. 
   
2. static Bitmap downloadBitmap(String url) {
   
3. final AndroidHttpClient client = AndroidHttpClient.newInstance("Android");
   
4. final HttpGet getRequest = new HttpGet(url);
   
5. 
   
6. try {
   
7. HttpResponse response = client.execute(getRequest);
   
8. final int statusCode = response.getStatusLine().getStatusCode();
   
9. if (statusCode != HttpStatus.SC_OK) {
   
10. Log.w("ImageDownloader", "Error " + statusCode + " while retrieving bitmap from " + url);
    
11. return null;
    
12. }
    
13. 
    
14. final HttpEntity entity = response.getEntity();
    
15. if (entity != null) {
    
16. InputStream inputStream = null;
    
17. try {
    
18. inputStream = entity.getContent();
    
19. final Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
    
20. return bitmap;
    
21. } finally {
    
22. if (inputStream != null) {
    
23. inputStream.close();
    
24. }
    
25. entity.consumeContent();
    
26. }
    
27. }
    
28. } catch (Exception e) {
    
29. // Could provide a more explicit error message for IOException or IllegalStateException
    
30. getRequest.abort();
    
31. Log.w("ImageDownloader", "Error while retrieving bitmap from " + url, e.toString());
    
32. } finally {
    
33. if (client != null) {
    
34. client.close();
    
35. }
    
36. }
    
37. return null;
    
38. }
    

复制代码

首先我们创建了一个HTTP客户端和HTTP请求。如果请求成功，就把响应中包含的图片内容解码成位图格式并返回，以备后续使用。另外补充一句，为了让程序可以访问网络，必须在程序的manifest文件中声明使用INTERNET。
注意：旧版的BitmapFactory.decodeStream有个bug，可能使得在网络较慢的时候无法正常工作。可以使用 FlushedInputStream(inputStream)代替原始的inputStream来解决这个问题。下面是这个helper class的实现：

1. 
   
2. static class FlushedInputStream extends FilterInputStream {
   
3. public FlushedInputStream(InputStream inputStream) {
   
4. super(inputStream);
   
5. }
   
6. 
   
7. @Override
   
8. public long skip(long n) throws IOException {
   
9. long totalBytesSkipped = 0L;
   
10. while (totalBytesSkipped < n) {
    
11. long bytesSkipped = in.skip(n - totalBytesSkipped);
    
12. if (bytesSkipped == 0L) {
    
13. int byte = read();
    
14. if (byte < 0) {
    
15. break; // we reached EOF
    
16. } else {
    
17. bytesSkipped = 1; // we read one byte
    
18. }
    
19. }
    
20. totalBytesSkipped += bytesSkipped;
    
21. }
    
22. return totalBytesSkipped;
    
23. }
    
24. }
    

复制代码

这个类可以保证skip()确实跳过了参数提供的字节数，直到流文件的末尾。

如果你在ListAdapter的getView方法中直接使用上面的downloadBitmap方法，结果可以想象的出，随着我们滚动屏幕，一定是一顿一顿很不爽的。因为每显示一个新的view，都必须等待一张图片完成下载，势必会影响滚屏的流畅度。

正是因为这想都想得出来的糟糕体验，AndroidHttpClient根本就不允许在主线程里启动！上面的代码在主线程里将会提示“本线程无法进行HTTP请求”。如果你不见棺材不落泪，说啥也要亲手试试这糟糕的用户体验的话，可以用DefaultHttpClient代替 AndroidHttpClient，给自己一个交代。

异步任务

AsyncTask类提供了一个从主线程生成新任务的方法。让我们创建一个ImageDownloader类来负责生成任务。这个类将提供一个download方法，从指定URL下载图片，并在ImageView里显示出来。

1. 
   
2. public class ImageDownloader {
   
3. 
   
4. public void download(String url, ImageView imageView) {
   
5. BitmapDownloaderTask task = new BitmapDownloaderTask(imageView);
   
6. task.execute(url);
   
7. }
   
8. }
   
9. 
   
10. /* class BitmapDownloaderTask, see below */
    
11. }
    

复制代码

BitmapDownloaderTask继承自AsyncTask。它真正执行图片下载的任务。任务通过execute方法启动，该方法是立即返回的，从而使得调用它的主线程代码可以迅速执行完毕。这正是我们使用AsyncTask的意义所在。下面是BitmapDownloaderTask的实现：

1. class BitmapDownloaderTask extends AsyncTask {
   
2. private String url;
   
3. private final WeakReference imageViewReference;
   
4. 
   
5. public BitmapDownloaderTask(ImageView imageView) {
   
6. imageViewReference = new WeakReference(imageView);
   
7. }
   
8. 
   
9. @Override
   
10. // Actual download method, run in the task thread
    
11. protected Bitmap doInBackground(String... params) {
    
12. // params comes from the execute() call: params[0] is the url.
    
13. return downloadBitmap(params[0]);
    
14. }
    
15. 
    
16. @Override
    
17. // Once the image is downloaded, associates it to the imageView
    
18. protected void onPostExecute(Bitmap bitmap) {
    
19. if (isCancelled()) {
    
20. bitmap = null;
    
21. }
    
22. 
    
23. if (imageViewReference != null) {
    
24. ImageView imageView = imageViewReference.get();
    
25. if (imageView != null) {
    
26. imageView.setImageBitmap(bitmap);
    
27. }
    
28. }
    
29. }
    
30. }
    

复制代码

doInBackground方法是真正在单独进程中执行异步任务的代码。它调用前面介绍的downloadBitmap方法，完成下载，取得位图。
onPostExecute在任务结束后由主线程调用。它通过传入的参数得到下载回来的位图，并设置到ImageView显示（该ImageView在实例化BitmapDownloaderTask时传入）。需要注意的是这里对ImageView的引用是以WeakReference的形式保存在 BitmapDownloaderTask实例里，所以在下载过程中如果activity被关掉，无法阻止activity里的ImageView被回收。因此我们必须在使用前检查imageViewReference和imageview是否为空。
这个简单的小例子演示了如何使用AsyncTask。如果你亲自动手实验一下，应该会发现这短短几行代码显著地改善了ListView的滚屏体验。推荐阅读developer.android.com的文章《Painless threading》来学习AsyncTasks的更多细节。
但是，这个基于ListView的例子暴露出一个问题。出于对内存的利用效率考虑，ListView会在用户滚屏的时候对view进行循环再利用。如果用户快速猛烈发飙般地滚屏，一个ImageView对象将会被反复使用多次。每一次它被显示出来，都会触发生成一个下载图片的任务，从而改变这个 ImageView的显示内容。那么问题在哪呢？跟大部分并行程序一样，关键问题在于顺序。在我们这个例子中，没有采取任何措施保证所有下载任务按顺序完成，换句话说，无法保证先启动的任务先完成，后启动的任务后完成。这样就导致显示在list中的图片可能来自之前的任务，该任务因为花费的时间更长，所以最后结束，最终导致预期外的结果。如果你要下载的图片们是一次性绑定到一坨ImageView的，那么就不存在问题，但我们还是从大局出发，为了通用的情况，修正一下吧。

并发处理

要想解决上面提到的问题，我们需要知道并保存下载任务的顺序，以保证最后启动的任务最后结束，并完成对ImageView的更新。要达到这个目的，让每个ImageView记住自己的最后一个下载任务就可以了。我们使用一个专用的Drawable类给ImageView添加这份信息。这个 Drawable类将在下载过程中临时绑定到ImageView。下面是这个DownloadedDrawable类的代码：

1. 
   
2. static class DownloadedDrawable extends ColorDrawable {
   
3. private final WeakReference bitmapDownloaderTaskReference;
   
4. 
   
5. public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) {
   
6. super(Color.BLACK);
   
7. bitmapDownloaderTaskReference =
   
8. new WeakReference(bitmapDownloaderTask);
   
9. }
   
10. 
    
11. public BitmapDownloaderTask getBitmapDownloaderTask() {
    
12. return bitmapDownloaderTaskReference.get();
    
13. }
    
14. }
    

复制代码

这个实现方法引入了一个ColorDrawable，这会导致ImageView在下载过程中显示黑色的背景。需要的话，可以使用一个显示“下载中…”之类的图片代替之，换取更友好的用户界面。再提一遍，注意使用WeakReference来降低与对象实例的耦合。
让我们修改之前的代码来让这个类起作用。首先，download方法将创建这个类的实例并绑定到ImageView：

1. 
   
2. public void download(String url, ImageView imageView) {
   
3. if (cancelPotentialDownload(url, imageView)) {
   
4. BitmapDownloaderTask task = new BitmapDownloaderTask(imageView);
   
5. DownloadedDrawable downloadedDrawable = new DownloadedDrawable(task);
   
6. imageView.setImageDrawable(downloadedDrawable);
   
7. task.execute(url, cookie);
   
8. }
   
9. }
   

复制代码

cancelPotentialDownload方法将在一个新的下载开始前取消尚在进行中的下载任务。注意，这并不足以保证新开始的下载任务得到的图片一定能够被显示，因为之前的任务可能已经完成了，处于等待onPostExecute方法执行的时间点，而这个onPostExecute方法还是有可能在新任务的onPostExecute方法之后执行。

1. 
   
2. private static boolean cancelPotentialDownload(String url, ImageView imageView) {
   
3. BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
   
4. 
   
5. if (bitmapDownloaderTask != null) {
   
6. String bitmapUrl = bitmapDownloaderTask.url;
   
7. if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) {
   
8. bitmapDownloaderTask.cancel(true);
   
9. } else {
   
10. // The same URL is already being downloaded.
    
11. return false;
    
12. }
    
13. }
    
14. return true;
    
15. }
    

复制代码

cancelPotentialDownload调用AsyncTask类的cancel方法来停止进行中的下载任务。大部分情况下它返回true，所以调用它的download方法中可以开始新的下载。唯一的例外情况是如果进行中的下载任务与新任务请求的是同一个URL，我们就不取消旧任务了，让它继续下载。注意在我们这个实现方法中，如果ImageView被回收了，与其关联的下载不会停止（可以借助RecyclerListener实现）。
这个方法还调用了一个helper函数getBitmapDownloaderTask。代码很直观，不做赘述:

1. 
   
2. private static BitmapDownloaderTask getBitmapDownloaderTask(ImageView imageView) {
   
3. if (imageView != null) {
   
4. Drawable drawable = imageView.getDrawable();
   
5. if (drawable instanceof DownloadedDrawable) {
   
6. DownloadedDrawable downloadedDrawable = (DownloadedDrawable)drawable;
   
7. return downloadedDrawable.getBitmapDownloaderTask();
   
8. }
   
9. }
   
10. return null;
    
11. }
    

复制代码

最后，必须修改一下onPostExecute方法，保证只在ImageView尚与下载进程关联的情况下绑定位图到ImageView：

1. 
   
2. if (imageViewReference != null) {
   
3. ImageView imageView = imageViewReference.get();
   
4. BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
   
5. // Change bitmap only if this process is still associated with it
   
6. if (this == bitmapDownloaderTask) {
   
7. imageView.setImageBitmap(bitmap);
   
8. }
   
9. }
   

复制代码

嗯，做了这些修改之后，我们的ImageDownloader类基本可以提供预期的服务了。你可以在自己的项目中灵活运用这些代码或者它演示的异步思想，改善用户体验。

Demo

本文的源代码可以从Google Code获取。你可以在本文提到的三种实现方式（非异步、无并发处理以及最终版本）中切换、比较。注意，缓存大小已经被限制到10张图片以便更好地演示可能出现的问题。

进一步的工作

文中代码为了集中讨论并行问题而做了简化，因此缺少很多功能。首先ImageDownloader类应该利用缓存，特别是与ListView结合使用的时候。因为ListView在用户上下往返滚屏的时候会多次显示相同图片，而缓存可以大大降低开销。通过使用一个基于LinkedHashMap（该 hashmap提供从URL到Bitmap SoftReference的映射）的LRU缓存可以很容易地实现这一点。更加复杂的缓存机制还可以依赖于本地存储。缩略图的创建、图片缩放等功能也可以考虑加进来。
本文代码已经考虑到了下载错误和超时的情况。这些情况下将会返回一个空位图。你也可以显示一张带有提示信息的图片。
本文示例的HTTP请求很简单。根据实际情况的不同（大都依赖于服务器端），可以在HTTP请求中加入各种参数或者cookie等等。
本文使用的AsyncTask类是一个把任务从主线程分离出来很简单方便的途径。你可能会用到Handler类来实现对任务流程更好的控制，比如控制并行的下载线程数，等等。


来自: http://hi.baidu.com/zhuawatianho ... 513109972b4398.html

yezj2004

朋友你好,想和你聊天！