非UI线程处理Bitmap

编写:kesenhoo - 原文:http://developer.android.com/training/displaying-bitmaps/process-bitmap.html

在上一课中介绍了一系列的BitmapFactory.decode*方法，当图片来源是网络或者是存储卡时（或者是任何不在内存中的形式），这些方法都不应该在UI 线程中执行。因为在上述情况下加载数据时，其执行时间是不可估计的，它依赖于许多因素（从网络或者存储卡读取数据的速度，图片的大小，CPU的速度等）。如果其中任何一个子操作阻塞了UI线程，系统都会容易出现应用无响应的错误。

这一节课会介绍如何使用AsyncTask在后台线程中处理Bitmap并且演示如何处理并发（concurrency）的问题。

使用AsyncTask(Use a AsyncTask)

AsyncTask 类提供了一个在后台线程执行一些操作的简单方法，它还可以把后台的执行结果呈现到UI线程中。下面是一个加载大图的示例：

  1. class BitmapWorkerTask extends AsyncTask {
  2.     private final WeakReference imageViewReference;
  3.     private int data = 0;
  5.     public BitmapWorkerTask(ImageView imageView) {
  6.         // Use a WeakReference to ensure the ImageView can be garbage collected
  7.         imageViewReference = new WeakReference(imageView);
  8.     }
  10.     // Decode image in background.
  11.     @Override
  12.     protected Bitmap doInBackground(Integer... params) {
  13.         data = params[0];
  14.         return decodeSampledBitmapFromResource(getResources(), data, 100, 100));
  15.     }
  17.     // Once complete, see if ImageView is still around and set bitmap.
  18.     @Override
  19.     protected void onPostExecute(Bitmap bitmap) {
  20.         if (imageViewReference != null && bitmap != null) {
  21.             final ImageView imageView = imageViewReference.get();
  22.             if (imageView != null) {
  23.                 imageView.setImageBitmap(bitmap);
  24.             }
  25.         }
  26.     }
  27. }

为ImageView使用WeakReference确保了AsyncTask所引用的资源可以被垃圾回收器回收。由于当任务结束时不能确保ImageView仍然存在，因此我们必须在onPostExecute()里面对引用进行检查。该ImageView在有些情况下可能已经不存在了，例如，在任务结束之前用户使用了回退操作，或者是配置发生了改变（如旋转屏幕等）。

开始异步加载位图，只需要创建一个新的任务并执行它即可:

  1. public void loadBitmap(int resId, ImageView imageView) {
  2.     BitmapWorkerTask task = new BitmapWorkerTask(imageView);
  3.     task.execute(resId);
  4. }

处理并发问题(Handle Concurrency)

通常类似ListView与GridView等视图控件在使用上面演示的AsyncTask 方法时，会同时带来并发的问题。首先为了更高的效率，ListView与GridView的子Item视图会在用户滑动屏幕时被循环使用。如果每一个子视图都触发一个AsyncTask，那么就无法确保关联的视图在结束任务时，分配的视图已经进入循环队列中，给另外一个子视图进行重用。而且， 无法确保所有的异步任务的完成顺序和他们本身的启动顺序保持一致。

Multithreading for Performance 这篇博文更进一步的讨论了如何处理并发问题，并且提供了一种解决方法：ImageView保存最近使用的AsyncTask的引用，这个引用可以在任务完成的时候再次读取检查。使用这种方式, 就可以对前面提到的AsyncTask进行扩展。

创建一个专用的Drawable的子类来储存任务的引用。在这种情况下，我们使用了一个BitmapDrawable，在任务执行的过程中，一个占位图片会显示在ImageView中:

  1. static class AsyncDrawable extends BitmapDrawable {
  2.     private final WeakReference bitmapWorkerTaskReference;
  4.     public AsyncDrawable(Resources res, Bitmap bitmap,
  5.             BitmapWorkerTask bitmapWorkerTask) {
  6.         super(res, bitmap);
  7.         bitmapWorkerTaskReference =
  8.             new WeakReference(bitmapWorkerTask);
  9.     }
  11.     public BitmapWorkerTask getBitmapWorkerTask() {
  12.         return bitmapWorkerTaskReference.get();
  13.     }
  14. }

在执行BitmapWorkerTask 之前，你需要创建一个AsyncDrawable并且将它绑定到目标控件ImageView中：

  1. public void loadBitmap(int resId, ImageView imageView) {
  2.     if (cancelPotentialWork(resId, imageView)) {
  3.         final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
  4.         final AsyncDrawable asyncDrawable =
  5.                 new AsyncDrawable(getResources(), mPlaceHolderBitmap, task);
  6.         imageView.setImageDrawable(asyncDrawable);
  7.         task.execute(resId);
  8.     }
  9. }

在上面的代码示例中，cancelPotentialWork 方法检查是否有另一个正在执行的任务与该ImageView关联了起来，如果的确是这样，它通过执行cancel()方法来取消另一个任务。在少数情况下, 新创建的任务数据可能会与已经存在的任务相吻合，这样的话就不需要进行下一步动作了。下面是 cancelPotentialWork方法的实现 。

  1. public static boolean cancelPotentialWork(int data, ImageView imageView) {
  2.     final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
  4.     if (bitmapWorkerTask != null) {
  5.         final int bitmapData = bitmapWorkerTask.data;
  6.         if (bitmapData == 0 || bitmapData != data) {
  7.             // Cancel previous task
  8.             bitmapWorkerTask.cancel(true);
  9.         } else {
  10.             // The same work is already in progress
  11.             return false;
  12.         }
  13.     }
  14.     // No task associated with the ImageView, or an existing task was cancelled
  15.     return true;
  16. }

在上面的代码中有一个辅助方法：getBitmapWorkerTask()，它被用作检索AsyncTask是否已经被分配到指定的ImageView:

  1. private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
  2.    if (imageView != null) {
  3.        final Drawable drawable = imageView.getDrawable();
  4.        if (drawable instanceof AsyncDrawable) {
  5.            final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
  6.            return asyncDrawable.getBitmapWorkerTask();
  7.        }
  8.     }
  9.     return null;
  10. }

最后一步是在BitmapWorkerTask的onPostExecute() 方法里面做更新操作:

  1. class BitmapWorkerTask extends AsyncTask {
  2.     ...
  4.     @Override
  5.     protected void onPostExecute(Bitmap bitmap) {
  6.         if (isCancelled()) {
  7.             bitmap = null;
  8.         }
  10.         if (imageViewReference != null && bitmap != null) {
  11.             final ImageView imageView = imageViewReference.get();
  12.             final BitmapWorkerTask bitmapWorkerTask =
  13.                     getBitmapWorkerTask(imageView);
  14.             if (this == bitmapWorkerTask && imageView != null) {
  15.                 imageView.setImageBitmap(bitmap);
  16.             }
  17.         }
  18.     }
  19. }

这个方法不仅仅适用于ListView与GridView控件，在那些需要循环利用子视图的控件中同样适用：只需要在设置图片到ImageView的地方调用 loadBitmap方法。例如，在GridView 中实现这个方法可以在 getView()中调用。