从用途上来说,线程分为主线程和子线程,主线程主要处理和界面相关的事情,而子线程则往往用于执行耗时操作。一个线程池中会缓存一定数量的线程,通过线程池就可以避免因为频繁创建和销毁线程所带来的系统开销。
1. 主线程和子线程
主线程是指进程所拥有的线程,在Java中默认情况下一个进程只有一个线程,这个线程就是主线程。子线程也叫工作线程,除了主线程以外的线程都是子线程。
Android沿用了Java的线程模型,其中的线程也分为主线程和子线程,其中主线程也叫UI线程。主线程的作用是运行四大组件以及处理它们和用户的交互,而子线程的作用则是执行耗时任务,比如网络请求、I/O操作等。
2. Android中的线程形态
1. AsyncTask
AsyncTask
是一种轻量级的异步任务类,它可以在线程池中执行后台任务,然后把执行的进度和最终结果传递给主线程并在主线程中更新UI。从实现上来说,AsyncTask
封装了Thread
和Handler
,通过AsyncTask
可以更加方便地执行后台任务以及在主线程中访问UI,但是AsyncTask
并不适合进行特别耗时的后台任务,对于特别耗时的任务来说,建议使用线程池。
AsyncTask
提供了4个核心方法,它们的含义如下所示。
onPreExecute()
,在主线程中执行,在异步任务执行之前,此方法会被调用,一般可以用于做一些准备工作。doInBackground(Params... params)
,在线程池中执行,此方法用于执行异步任务,params
参数表示异步任务的输入参数。在此方法中可以通过publishProgress
方法来更新任务的进度,publishProgress
方法会调用onProgressUpdate
方法。另外此方法需要返回计算结果给onPostExecute
方法。onProgressUpdate(Progress... values)
,在主线程中执行,当后台任务的执行进度发生改变时此方法会被调用。onPostExecute(Result result)
,在主线程中执行,在异步任务执行之后,此方法会被调用,其中result
参数是后台任务的返回值,即doInBackground
的返回值。
2. AsyncTask的工作原理
- 为了分析
AsyncTask
的工作原理,从它的execute
方法开始分析,execute
方法又会调用executeOnExecutor
方法。
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task: the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task: the task has already been executed (a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
- 一个进程中所有的
AsyncTask
全部在它内部的静态的串行线程池sDefaultExecutor
中排队执行。在executeOnExecutor
方法中,AsyncTask
的onPreExecute
方法最先执行,然后线程池开始执行。
public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
- 从
SerialExecutor
的实现可以分析AsyncTask
的排队执行的过程。当一个AsyncTask
任务执行完后,AsyncTask
会继续执行其他任务直到所有的任务都被执行为止(因为同一进程的所有AsyncTask
使用同一个静态的SerialExecutor
),从这一点可以看出,在默认情况下,AsyncTask
是串行执行的。
AsyncTask
中有两个线程池,其中线程池SerialExecutor
用于任务的排队,而线程池THREAD_POOL_EXECUTOR
用于真正地执行任务。由于FutureTask
的run
方法会调用mWorker
的call
方法,因此mWorker
的call
方法最终会在线程池中执行。
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
- 在
mWorker
的call
方法中,执行AsyncTask
的doInBackground
方法,接着将其返回值传递给postResult
方法:
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
postResult
方法会通过sHandler
发送一个MESSAGE_POST_RESULT
的消息,这个sHandler
的定义如下:
private static final InternalHandler sHandler = new InternalHandler();
private static class InternalHandler extends Handler {
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
sHandler
是一个静态的Handler
对象,为了能够将执行环境切换到主线程,这就要求AsyncTask
的类必须在主线程中加载。sHandler
收到MESSAGE_POST_RESULT
这个消息后会调用AsyncTask
的finish
方法。可以看到doInBackground
的返回结果会传递给onPostExecute
方法,到这里AsyncTask
的整个工作过程就分析完毕了。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
为了让AsyncTask
可以在Android 3.0及以上的版本上并行,可以采用AsyncTask
的executeOnExecutor
方法。
new MyAsyncTask("AsyncTask#1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
private static class MyAsyncTask extends AsyncTask<String, Integer, String> {
...
}
3. HandlerThread
HandlerThread
继承了Thread
,它是一种可以使用Handler
的Thread
。
普通Thread
主要用于在run
方法中执行一个耗时任务,而HandlerThread
在内部创建了消息队列,外界需要通过Handler
的消息方式来通知HandlerThread
执行一个具体的任务。HandlerThread
在Android中的一个具体的使用场景是IntentService
。
4. IntentService
IntentService
继承了Service
并且它是一个抽象类。IntentService
可用于执行后台耗时的任务,当任务执行后它会自动停止,同时由于IntentService
是服务的原因,这导致它的优先级比单纯的线程要高很多,所以IntentService
比较适合执行一些高优先级的后台任务。在实现上,IntentService
封装了HandlerThread
和Handler
。
由于每执行一个后台任务就必须启动一次IntentService
,而IntentService
内部则通过消息的方式向HandlerThread
请求执行任务,Handler
中的Looper
是顺序处理消息的,这就意味着IntentService
也是顺序执行后台任务的,当有多个后台任务同时存在时,这些后台任务会按照外界发起的顺序排队执行。
3. Android中的线程池
线程池的优点可以概括为以下三点:
- 重用线程池中的线程,避免因为线程的创建和销毁所带来的性能开销。
- 能有效控制线程池的最大并发数,避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
- 能够对线程进行简单的管理,并提供定时执行以及指定间隔循环执行等功能。
Android中的线程池都是直接或者间接通过配置ThreadPoolExecutor
来实现的。
1. ThreadPoolExecutor
ThreadPoolExecutor
是线程池的真正实现,它的构造方法提供了一系列参数来配置线程池。
public ThreadPoolExecutor(int corePoolSize, // 线程池的核心线程数
int maximumPoolSize, // 线程池所能容纳的最大线程数
long keepAliveTime, // 非核心线程闲置时的超时时长
TimeUnit unit, // 用于指定keepAliveTime参数的时间单位
BlockingQueue<Runnable> workQueue, // 线程池中的任务队列
ThreadFactory threadFactory) // 线程工厂,为线程池提供创建新线程的功能
ThreadPoolExecutor
执行任务时大致遵循如下规则:
- 如果线程池中的线程数量未达到核心线程的数量,那么会直接启动一个核心线程来执行任务。
- 如果线程池中的线程数量已经达到或者超过核心线程的数量,那么任务会被插入到任务队列中排队等待执行。
- 如果在步骤2中无法将任务插入到任务队列中,这往往是由于任务队列已满,这个时候如果线程数量未达到线程池规定的最大值,那么会立刻启动一个非核心线程来执行任务。
- 如果步骤3中线程数量已经达到线程池规定的最大值,那么就拒绝执行此任务,
ThreadPoolExecutor
会调用RejectedExecutionHandler
的rejectedExecution
方法来通知调用者。
2. 线程池的分类
Android中最常见的四类具有不同功能特性的线程池,它们都直接或间接地通过配置ThreadPoolExecutor
来实现自己的功能特性。
1. FixedThreadPool
通过Executors
的newFixedThreadPool
方法来创建。FixedThreadPool中只有核心线程并且这些核心线程没有超时机制不会被回收,这意味着它能够更加快速地响应外界的请求,另外任务队列也是没有大小限制的,
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
2. CachedThreadPool
通过Executors
的newCachedThreadPool
方法来创建。和FixedThreadPool
不同的是,CachedThreadPool的任务队列其实相当于一个空集合,这将导致任何任务都会立即被执行。这类线程池比较适合执行大量的耗时较少的任务。当整个线程池都处于闲置状态时,线程池中的线程都会超时而被停止,这个时候CachedThreadPool之中实际上是没有任何线程的,它几乎是不占用任何系统资源的。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
}
3. ScheduledThreadPool
通过Executors
的newScheduledThreadPool
方法来创建。ScheduledThreadPool主要用于执行定时任务和具有固定周期的重复任务。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());
}
4. SingleThreadExecutor
通过Executors
的newSingleThreadExecutor
方法来创建。SingleThreadExecutor的意义在于统一所有的外界任务到一个线程中,这使得在这些任务之间不需要处理线程同步的问题。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));
}