Picasso中的多线程

Picasso的使用及源码提交请求流程网上都已经很多了，本篇只分析Picasso中多线程相关

1. Picasso的线程池

Picasso的线程池是在Picasso.Builder.build()方法中创建的

if (service == null) {
        service = new PicassoExecutorService();
      }

而PicassoExecutorService是继承自ThreadPoolExecutor

  //初始化函数
  private static final int DEFAULT_THREAD_COUNT = 3;

  PicassoExecutorService() {
    super(DEFAULT_THREAD_COUNT, DEFAULT_THREAD_COUNT, 0, TimeUnit.MILLISECONDS,
        new PriorityBlockingQueue(), new Utils.PicassoThreadFactory());
  }

可以看到核心线程数和最大线程数都是3个，并且使用了优先级队列，PriorityBlockingQueue() ，而此队列是无界队列，所以不需要最大线程数比核心线程数多且不需要设置保持存活时间。
那么问题来了，提交的时候优先级怎么排序的，看下面

//PicassoExecutorService.class
  @Override
  public Future submit(Runnable task) {
    PicassoFutureTask ftask = new PicassoFutureTask((BitmapHunter) task);
    execute(ftask);
    return ftask;
  }

重写了submit接口，返回了自封装的PicassoFutureTask，

private static final class PicassoFutureTask extends FutureTask
      implements Comparable {
    private final BitmapHunter hunter;

    public PicassoFutureTask(BitmapHunter hunter) {
      super(hunter, null);
      this.hunter = hunter;
    }

    @Override
    public int compareTo(PicassoFutureTask other) {
      Picasso.Priority p1 = hunter.getPriority();
      Picasso.Priority p2 = other.hunter.getPriority();

      // High-priority requests are "lesser" so they are sorted to the front.
      // Equal priorities are sorted by sequence number to provide FIFO ordering.
      return (p1 == p2 ? hunter.sequence - other.hunter.sequence : p2.ordinal() - p1.ordinal());
    }
  }

其实主要是重写了compareTo接口，根据BitmapHunter的priority对请求排序，而BitmapHunter就是提交到线程池里的Runnable

继续看线程池用到的线程工厂new Utils.PicassoThreadFactory()

//Util.java
static class PicassoThreadFactory implements ThreadFactory {
    @SuppressWarnings("NullableProblems")
    public Thread newThread(Runnable r) {
      return new PicassoThread(r);
    }
  }
private static class PicassoThread extends Thread {
    public PicassoThread(Runnable r) {
      super(r);
    }

    @Override public void run() {
      Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND);
      super.run();
    }
  }

仅仅只是设置了一下线程优先级为后台线程

2. Picasso UI对应的handler为

static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
    @Override public void handleMessage(Message msg) {
          ...
      }
    }
  };

是个静态常量，生命周期是app的生命周期。为啥呢，原因是Picasso里的Context是applicationContext()。

//Picasso$Builder的构造函数
public Builder(Context context) {
      if (context == null) {
        throw new IllegalArgumentException("Context must not be null.");
      }
      this.context = context.getApplicationContext();
    }
//build方法
public Picasso build() {
      Context context = this.context;
...
      return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
          defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
    }

那问题来了，下载图片的activity或者fragment销毁后不会内存泄漏吗？
请看下面

//Picasso构造函数
Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener,
      RequestTransformer requestTransformer, List extraRequestHandlers, Stats stats,
      Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
...
this.referenceQueue = new ReferenceQueue