Picasso使用Target无法回调的分析与解决

注：文章转载自文章转载自RowandJJ的博客：http://blog.csdn.net/chdjj/article/details/49964901

在加载图片的场景中，有时需要异步拿到Bitmap做一些操作：bitmap预热、bitmap裁剪等，当加载成功的时候通过回调的形式来获取Bitmap，然后进行处理。Picasso提供了一种回调的方式获取Bitmap。客户端实现Target接口即可在加载成功的时候通过回调的方式返回bitmap。代码如下：

Picasso.with(context).load(url).into(new Target() {
  @Override public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
    //加载成功，进行处理
  }

  @Override public void onBitmapFailed(Drawable errorDrawable) {
    //加载失败
  }

  @Override public void onPrepareLoad(Drawable placeHolderDrawable) {
    //开始加载
  }
});
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
   
   

    
    
   
   

通过上面的回调函数，我们就可以获取Bitmap，然后进行bitmap的自定义处理。
但是有时候回调却没有触发，也没有异常，最后开启Picasso日志，才发现target引用被gc掉了：

一、异步回调的陷阱

后面查看源码之后才发现，由于Picasso将target引用包装成了一个弱引用，当gc发生时target引用就很可能被回收从而无法回调。
首先，先看into(target)源码：

public void into(Target target) {
//代码省略....
//将target作为参数，实例化一个targetAction，此处Action表示picasso的一个抽象行为。
Action action = new TargetAction(picasso, target, request, memoryPolicy, networkPolicy, errorequestKey, tag, errorResId);

}
   
   
1
2
3
4
5
6
   
   

    
    
   
   

这里我们可以看到，首先picasso会判断是否从内存中读取，如果不从内存中读取，那么就创建一个新的Action任务，将target作为参数给TargetAction持有。重要关注TargetAction这个类，我们再看一看TargetAction类的构造有什么内容：

final class TargetAction extends Action<Target> {

   TargetAction(Picasso picasso, Target target, Request data, int memoryPolicy,Drawable errorDrawable, String key, Object tag, int errorResId) {
      super(picasso, target, data, memoryPolicy, networkPolicy, errorResId, errorDraw，false);
   }
// 代码省略
}
   
   
1
2
3
4
5
6
7
   
   

    
    
   
   

这里可以看到，TargetAction继承了Action类，target引用传给了父类Action的构造函数：

abstract class Action<T> {
//picasso实现的弱引用
  static class RequestWeakReference<M> extends WeakReference<M> {
    final Action action;
    public RequestWeakReference(Action action, M referent, ReferenceQueue<? super>){
       super(referent, q);
       this.action = action;
    }
  }
  final Picasso picasso;
  final Request request;
  final WeakReference<T> target;
  final boolean noFade;

  Action(Picasso picasso, T target, Request request, int memoryPolicy, int network,int errorResId, Drawable errorDrawable, String key, Object tag, boolean ){
    this.picasso = picasso;
    this.request = request;
    //如果target不是null，那么就将其包裹为弱引用！同时关联到
    //picasso的referenceQueue中。
    this.target = target == null ? null : new 
        RequestWeakReference<T>(this, target, 
               picasso.referenceQueue);
    //...省略
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
   
   

    
    
   
   

在Action的构造函数中将target包裹为弱引用，同时关联至picasso的referenceQueue中。这里原因已经出来了，就是因为target是弱引用，因此无法阻止正常的gc过程，只要回调之前发生了gc回收，那么target很有可能就被回收掉了。一旦target被回收，那么也就无法回调了。
将target的弱引用关联至Picasso.referenceQueue是为了监听target被回收的状态,Picasso有一个专门监听target引用的线程CleanupThread，该线程会将监听到的GC事件传递给Picasso的Handler：

private static class CleanupThread extends Thread {
  private final ReferenceQueue<Object> referenceQueue;
  private final Handler handler;

  CleanupThread(ReferenceQueue<Object> referenceQueue, 
  Handler handler) {
     this.referenceQueue = referenceQueue;
     this.handler = handler;
     setDaemon(true);
     setName(THREAD_PREFIX + "refQueue");
  }

  @Override public void run() {
     Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND);
     while (true) {
       try {
       //这里开启了一个死循环，每秒钟从referenceQueue中拿到被
       //gc标志的target引用
       RequestWeakReference<?> remove =
       referenceQueue.remove(THREAD_LEAK_CLEANING_M);
       Message message = handler.obtainMessage();
       //如果引用尚未为空，说明尚未gc掉（但仍然会gc），则发出被
       //GC的通知，REQUEST_GCED通知
       if (remove != null) {
         message.what = REQUEST_GCED;
         message.obj = remove.action;
         handler.sendMessage(message);
       } else {
       message.recycle();
     }
    } catch (InterruptedException e) {
       break;
    } catch (final Exception e) {
       handler.post(new Runnable() {
         @Override public void run() {
           throw new RuntimeException(e);
   }
    });
  break;
  }
 }
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
   
   

    
    
   
   

该线程从Picasso构造函数起执行：

Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener,...){ 
  //省略
  //创建引用队列，被gc标志的引用在被gc前都会首加入其中
  this.referenceQueue = new ReferenceQueue<Object>();
  //创建并执行监听线程
  this.cleanupThread = new 
  CleanupThread(referenceQueue, HANDLER);
  this.cleanupThread.start();
}
   
   
1
2
3
4
5
6
7
8
9
   
   

    
    
   
   

当Picasso的Handler收到REQUEST_GCED消息时会撤销当前请求：

static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
  @Override 
  public void handleMessage(Message msg) {
    switch (msg.what) {
      //图片加载成功
      case HUNTER_BATCH_COMPLETE: {
      @SuppressWarnings("unchecked") 
      List<BitmapHunter> batch = (List<Action>) msg.obj;
      //noinspection ForLoopReplaceableByForEach
      //发起通知
     for (int i = 0, n = batch.size(); i < n; i++) {
       BitmapHunter hunter = batch.get(i);
       hunter.picasso.complete(hunter);
     }
     break;
   }
   //GC消息
   case REQUEST_GCED: {
     Action action = (Action) msg.obj;
     if (action.getPicasso().loggingEnabled) {
       log(OWNER_MAIN, VERB_CANCELED, action.request.logId(), "target got garbage collected!");
     }
   //取消当前请求
    action.picasso.cancelExistingRequest(action.getTarget());
    break;
   }
   case REQUEST_BATCH_RESUME:
   @SuppressWarnings("unchecked") 
   List<Action> batch = (List<Action>) msg.obj;
   //noinspection ForLoopReplaceableByForEach
   for (int i = 0, n = batch.size(); i < n; i++) {
     Action action = batch.get(i);
     action.picasso.resumeAction(action);
   }
   break;
   default:
     throw new AssertionError("Unknown handler message 
     received: " + msg.what);
   }
 }
};
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
   
   

    
    
   
   

从上面的分析我们可以得出结论：使用Target获取bitmap并不保险，无法保证一定能够获得Bitmap。

二、解决方案

2.1 阻止gc（不建议）

既然是因为弱引用造成的gc，那么让系统无法将target进行gc就可以了。开发者在加载图片的周期内持有target的强引用，在获取到bitmap之后再将其释放即可。但是这样违背了设计者的设计初衷，也容易引发内存泄漏的问题，原本设计者就是想让target异步回调的形式不影响正常的gc回调。

设计者的原因很简单：如果一个view实现了target接口，那么view的生命周期就会被target影响，造成内存泄漏。
比如：在图片加载期间，View可能已经离开了屏幕，将要被回收；或者Activity将要被销毁。但是由于picasso还没有加载完成，持有着view的引用，而view又持有Activity的引用，造成View和Activity都无法被回收。

2.2 使用get()的方式获取Bitmap

除了使用Target来进行异步获取，Picasso还提供了一个get()方法，进行同步的获取:

public Bitmap get() throws IOException {
   //省略...
   Request finalData = createRequest(started);
   String key = createKey(finalData, new StringBuilder());
   Action action = new GetAction(picasso, finalData, memoryPolicy, networkPolicy, tBitmapHunter);

   //forRequest(xxx)返回的是一个BitmapHunter(继承了
     Runnable)，直接调用其中的hunt（）方法获
   return forRequest(picasso, picasso.dispatcher, picasso.cache, picasso.stats,...);
}
   
   
1
2
3
4
5
6
7
8
9
10
   
   

    
    
   
   

BitmapHunter:

class BitmapHunter implements Runnable {
  //...此处省略N行代码
  //获取bitmap
  Bitmap hunt() throws IOException {
    Bitmap bitmap = null;
    //内存获取
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      bitmap = cache.get(key);
      if (bitmap != null) {
        stats.dispatchCacheHit();
        loadedFrom = MEMORY;
        if (picasso.loggingEnabled) {
          log(OWNER_HUNTER, VERB_DECODED, data.logId(), "from cache");
     }
    return bitmap;
    }
  }
  //网络获取
  data.networkPolicy = retryCount == 0 ? 
  NetworkPolicy.OFFLINE.index : networkPoli
  RequestHandler.Result result = 
  requestHandler.load(data, networkPolicy);
  if (result != null) {
    loadedFrom = result.getLoadedFrom();
    exifRotation = result.getExifOrientation();
    bitmap = result.getBitmap();
    //If there was no Bitmap then we need to decode 
    it from the stream.
    if (bitmap == null) {
      InputStream is = result.getStream();
      try {
        bitmap = decodeStream(is, data);
      } finally {
        Utils.closeQuietly(is);
      }
    }
  }
  //bitmap的解码、transform操作
  if (bitmap != null) {
     if (picasso.loggingEnabled) {
       log(OWNER_HUNTER, VERB_DECODED, data.logId());
     }
     stats.dispatchBitmapDecoded(bitmap);
     if (data.needsTransformation() || exifRotation != 0) {
       synchronized (DECODE_LOCK) {
       if (data.needsMatrixTransform() || exifRotation != 0){
         bitmap = transformResult(data, bitmap, exifRotation);
         if (picasso.loggingEnabled) {
           log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId());
         }
       }
       if (data.hasCustomTransformations()) {
          bitmap = applyCustomTransformations
               (data.transformations, bitmap);
          if (picasso.loggingEnabled) {
             log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId(), "from custom transformation");
           }
        }
       }
       if (bitmap != null) {
          stats.dispatchBitmapTransformed(bitmap);
       }
    }
  }
  return bitmap;
  }
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
   
   

    
    
   
   

我们如果想通过get来实现异步获取，那么就使用一个线程池进行get()方法调用就可以了：

/** 

* 同步获取Bitmap，这种方式会在子线程当中同步去获取Bitmap，不会采用回调的方式，也不会存在引用被 

* 要么获取成功；要么获取失败；或者抛出异常。 

*/ 

private void fetchBySync(IFacadeBitmapCallback target) { 

    threadPoolExecutor.submit(() -> { 

       Bitmap bitmap = null; 

       try { 

         bitmap = requestCreator.get(); 

       } catch (IOException e) { 

          e.printStackTrace(); 

          target.onBitmapFailed(path, e); 

       } 

       if (bitmap == null) { 

          Log.e(getClass().getSimpleName(), "bitmap is null"); 

          target.onBitmapFailed(path, null); 

       } else { 

          Log.e(getClass().getSimpleName(), "bitmap " + bitmap.getClass().getSimpleName()); 

          target.onBitmapLoaded(path, bitmap); 

       } 

 }
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21