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

Posted 2023-02-15 David-Kuper

• • 一异步回调的陷阱
  • 二解决方案
    • 1 阻止gc不建议
    • 2 使用get的方式获取Bitmap

在加载图片的场景中，有时需要异步拿到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) 
    //开始加载
  
);

通过上面的回调函数，我们就可以获取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);

这里我们可以看到，首先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);
   
// 代码省略

这里可以看到，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);
    //...省略

在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;
  
 

该线程从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();

当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);
   
 
;

从上面的分析我们可以得出结论：使用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,...);

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;
  

我们如果想通过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);