Executors類提供了4種不同的線程池：newCachedThreadPool、newFixedThreadPool、 newScheduledThreadPool和newSingleThreadExecutor，它們都是直接或間接通過ThreadPoolExecutor實現的。
*ThreadPoolExecutor:
// Public constructors and methods
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
* parameters and default thread factory and rejected execution handler.
* It may be more convenient to use one of the {@link Executors} factory
* methods instead of this general purpose constructor.
*
* @param corePoolSize the number of threads to keep in the pool, even
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
* @param maximumPoolSize the maximum number of threads to allow in the
* pool
* @param keepAliveTime when the number of threads is greater than
* the core, this is the maximum time that excess idle threads
* will wait for new tasks before terminating.
* @param unit the time unit for the {@code keepAliveTime} argument
* @param workQueue the queue to use for holding tasks before they are
* executed. This queue will hold only the {@code Runnable}
* tasks submitted by the {@code execute} method.
* @throws IllegalArgumentException if one of the following holds:<br>
* {@code corePoolSize < 0}<br>
* {@code keepAliveTime < 0}<br>
* {@code maximumPoolSize <= 0}<br>
* {@code maximumPoolSize < corePoolSize}
* @throws NullPointerException if {@code workQueue} is null
*/
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue)
ThreadPoolExecutor的構造方法有以下幾個重要參數：
corePoolSize：核心線程數。核心線程會在線程池中一直存活，即時它們處于閑置狀態，例外情況是allowCoreThreadTimeOut被設置為true。
maximumPoolSize：最大線程數。
keepAliveTime：線程閑置時的超時時長，超時后線程會被回收。
unit：keepAliveTime的時間單位。
workQueue：存放等待執行的任務的阻塞隊列。
隊列與線程池按照以下規則進行交互：
如果運行的線程數小于核心線程數（corePoolSize），則首選添加新線程而不排隊。如果運行的線程數等于或者大于核心線程數（corePoolSize），則首選將請求加入隊列而不添加新線程。如果請求無法加入隊列，則創建新線程；如果這將導致超出最大線程數（maximumPoolSize），則任務將被拒絕執行。
*Executors:
/**
* Creates a thread pool that reuses a fixed number of threads
* operating off a shared unbounded queue. At any point, at most
* {@code nThreads} threads will be active processing tasks.
* If additional tasks are submitted when all threads are active,
* they will wait in the queue until a thread is available.
* If any thread terminates due to a failure during execution
* prior to shutdown, a new one will take its place if needed to
* execute subsequent tasks. The threads in the pool will exist
* until it is explicitly {@link ExecutorService#shutdown shutdown}.
*
* @param nThreads the number of threads in the pool
* @return the newly created thread pool
* @throws IllegalArgumentException if {@code nThreads <= 0}
*/
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
可以看到FixedThreadPool只有固定數量的核心線程，任務隊列是基于鏈表的無界阻塞隊列。當所有線程都在運行時，新任務都會放到任務隊列中等待。
默認情況下，Glide的網絡請求是在EngineJob中的sourceExecutor中執行的，而這個sourceExecutor是通過GlideExecutor的newSourceExecutor方法實例化的。
*GlideExecutor:
/**
* Returns a new fixed thread pool with the default thread count returned from
* {@link #calculateBestThreadCount()}, the {@link #DEFAULT_SOURCE_EXECUTOR_NAME} thread name
* prefix, and the
* {@link com.bumptech.glide.load.engine.executor.GlideExecutor.UncaughtThrowableStrategy#DEFAULT}
* uncaught throwable strategy.
*
* <p>Source executors allow network operations on their threads.
*/
public static GlideExecutor newSourceExecutor() {
return newSourceExecutor(calculateBestThreadCount(), DEFAULT_SOURCE_EXECUTOR_NAME,
UncaughtThrowableStrategy.DEFAULT);
}
/**
* Returns a new fixed thread pool with the given thread count, thread name prefix,
* and {@link com.bumptech.glide.load.engine.executor.GlideExecutor.UncaughtThrowableStrategy}.
*
* <p>Source executors allow network operations on their threads.
*
* @param threadCount The number of threads.
* @param name The prefix for each thread name.
* @param uncaughtThrowableStrategy The {@link
* com.bumptech.glide.load.engine.executor.GlideExecutor.UncaughtThrowableStrategy} to use to
* handle uncaught exceptions.
*/
public static GlideExecutor newSourceExecutor(int threadCount, String name,
UncaughtThrowableStrategy uncaughtThrowableStrategy) {
return new GlideExecutor(threadCount, name, uncaughtThrowableStrategy,
false /*preventNetworkOperations*/, false /*executeSynchronously*/);
}
// Visible for testing.
GlideExecutor(int poolSize, String name,
UncaughtThrowableStrategy uncaughtThrowableStrategy, boolean preventNetworkOperations,
boolean executeSynchronously) {
this(
poolSize /* corePoolSize */,
poolSize /* maximumPoolSize */,
0 /* keepAliveTimeInMs */,
name,
uncaughtThrowableStrategy,
preventNetworkOperations,
executeSynchronously);
}
GlideExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTimeInMs, String name,
UncaughtThrowableStrategy uncaughtThrowableStrategy, boolean preventNetworkOperations,
boolean executeSynchronously) {
this(
corePoolSize,
maximumPoolSize,
keepAliveTimeInMs,
name,
uncaughtThrowableStrategy,
preventNetworkOperations,
executeSynchronously,
new PriorityBlockingQueue<Runnable>());
}
GlideExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTimeInMs, String name,
UncaughtThrowableStrategy uncaughtThrowableStrategy, boolean preventNetworkOperations,
boolean executeSynchronously, BlockingQueue<Runnable> queue) {
super(
corePoolSize,
maximumPoolSize,
keepAliveTimeInMs,
TimeUnit.MILLISECONDS,
queue,
new DefaultThreadFactory(name, uncaughtThrowableStrategy, preventNetworkOperations));
this.executeSynchronously = executeSynchronously;
}
/**
* Determines the number of cores available on the device.
*
* <p>{@link Runtime#availableProcessors()} returns the number of awake cores, which may not
* be the number of available cores depending on the device's current state. See
* http://goo.gl/8H670N.
*/
public static int calculateBestThreadCount() {
// We override the current ThreadPolicy to allow disk reads.
// This shouldn't actually do disk-IO and accesses a device file.
// See: https://github.com/bumptech/glide/issues/1170
ThreadPolicy originalPolicy = StrictMode.allowThreadDiskReads();
File[] cpus = null;
try {
File cpuInfo = new File(CPU_LOCATION);
final Pattern cpuNamePattern = Pattern.compile(CPU_NAME_REGEX);
cpus = cpuInfo.listFiles(new FilenameFilter() {
@Override
public boolean accept(File file, String s) {
return cpuNamePattern.matcher(s).matches();
}
});
} catch (Throwable t) {
if (Log.isLoggable(TAG, Log.ERROR)) {
Log.e(TAG, "Failed to calculate accurate cpu count", t);
}
} finally {
StrictMode.setThreadPolicy(originalPolicy);
}
int cpuCount = cpus != null ? cpus.length : 0;
int availableProcessors = Math.max(1, Runtime.getRuntime().availableProcessors());
return Math.min(MAXIMUM_AUTOMATIC_THREAD_COUNT, Math.max(availableProcessors, cpuCount));
}
GlideExecutor的newSourceExecutor與Executors的newFixedThreadPool類似，都是固定大小的線程池，不過任務隊列不同。線程池大小為calculateBestThreadCount，該值為設備可用核心數但最大不超過4。任務隊列為PriorityBlockingQueue，一種基于優先級的無界阻塞隊列，插入元素需要實現Comparable接口的compareTo方法來提供排序依據。
*DecodeJob:
@Override
public int compareTo(DecodeJob<?> other) {
int result = getPriority() - other.getPriority();
if (result == 0) {
result = order - other.order;
}
return result;
}
Glide的Runnable實現類是DecodeJob，它的compareTo方法的邏輯是：優先級（共IMMEDIATE／HIGH／NORMAL／LOW四種，依次降低，默認為NORMAL）高的優先，若優先級相同則順序在前的優先（先進先出）。
*RequestBuilder:
/**
* Set the target the resource will be loaded into.
*
* @param target The target to load the resource into.
* @return The given target.
* @see RequestManager#clear(Target)
*/
public <Y extends Target<TranscodeType>> Y into(@NonNull Y target) {
Util.assertMainThread();
Preconditions.checkNotNull(target);
if (!isModelSet) {
throw new IllegalArgumentException("You must call #load() before calling #into()");
}
Request previous = target.getRequest();
if (previous != null) {
requestManager.clear(target);
}
requestOptions.lock();
Request request = buildRequest(target);
target.setRequest(request);
requestManager.track(target, request);
return target;
}
*HttpUrlFetcher:
@Override
public void loadData(Priority priority, DataCallback<? super InputStream> callback) {
long startTime = LogTime.getLogTime();
final InputStream result;
try {
result = loadDataWithRedirects(glideUrl.toURL(), 0 /*redirects*/, null /*lastUrl*/,
glideUrl.getHeaders());
} catch (IOException e) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Failed to load data for url", e);
}
callback.onLoadFailed(e);
return;
}
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "Finished http url fetcher fetch in " + LogTime.getElapsedMillis(startTime)
+ " ms and loaded " + result);
}
callback.onDataReady(result);
}
private InputStream loadDataWithRedirects(URL url, int redirects, URL lastUrl,
Map<String, String> headers) throws IOException {
if (redirects >= MAXIMUM_REDIRECTS) {
throw new HttpException("Too many (> " + MAXIMUM_REDIRECTS + ") redirects!");
} else {
// Comparing the URLs using .equals performs additional network I/O and is generally broken.
// See http://michaelscharf.blogspot.com/2006/11/javaneturlequals-and-hashcode-make.html.
try {
if (lastUrl != null && url.toURI().equals(lastUrl.toURI())) {
throw new HttpException("In re-direct loop");
}
} catch (URISyntaxException e) {
// Do nothing, this is best effort.
}
}
urlConnection = connectionFactory.build(url);
for (Map.Entry<String, String> headerEntry : headers.entrySet()) {
urlConnection.addRequestProperty(headerEntry.getKey(), headerEntry.getValue());
}
urlConnection.setConnectTimeout(timeout);
urlConnection.setReadTimeout(timeout);
urlConnection.setUseCaches(false);
urlConnection.setDoInput(true);
// Stop the urlConnection instance of HttpUrlConnection from following redirects so that
// redirects will be handled by recursive calls to this method, loadDataWithRedirects.
urlConnection.setInstanceFollowRedirects(false);
// Connect explicitly to avoid errors in decoders if connection fails.
urlConnection.connect();
if (isCancelled) {
return null;
}
final int statusCode = urlConnection.getResponseCode();
if (statusCode / 100 == 2) {
return getStreamForSuccessfulRequest(urlConnection);
} else if (statusCode / 100 == 3) {
String redirectUrlString = urlConnection.getHeaderField("Location");
if (TextUtils.isEmpty(redirectUrlString)) {
throw new HttpException("Received empty or null redirect url");
}
URL redirectUrl = new URL(url, redirectUrlString);
return loadDataWithRedirects(redirectUrl, redirects + 1, url, headers);
} else if (statusCode == -1) {
throw new HttpException(statusCode);
} else {
throw new HttpException(urlConnection.getResponseMessage(), statusCode);
}
}
@Override
public void cancel() {
// TODO: we should consider disconnecting the url connection here, but we can't do so
// directly because cancel is often called on the main thread.
isCancelled = true;
}
Glide將加載請求和Target(ImageView)關聯，開始某個ImageView的加載請求前會先將該ImageView關聯的請求清除。此時在線程池中的關聯的DecodeJob，正在進行的網絡請求不會被中斷，在等待隊列里的也不會被直接從線程池移除，而是移除回調并設置取消標志位，讓未開始的后續加載步驟的邏輯不會被執行。
當列表（ListView/RecyclerView）快速滾動時，同時執行的網絡請求數量不會超過設備可用核心數，其余請求會放到隊列中等待執行。雖然隊列長度可能會一下增加到幾十，但隨著列表復用View，隊列中的大部分請求都會被取消掉，之后執行時不會發起網絡請求，并迅速讓位于等待中的請求。也就是說，快速滾動過程的中間很多個列表項的請求都會被略過。這樣的機制保證了不會過度消耗資源導致滑動卡頓。
