主线程和子线程
主线程，又叫UI线程，主要作用是运行四大组件以及处理它们和用户的交互。子线程也叫工程线程，主要作用是执行耗时任务，比如网络请求，I/O操作等。在安卓中，主线程不能执行耗时操作（避免主线程由于被耗时操作所阻塞从而出现ANR现象），子线程不能更新UI。
Android中的线程形态
1. AsyncTask
1.1 AsyncTask介绍
AsyncTask是一个轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递个主线程并在主线程中更新UI。从代码实现上看，AsyncTask封装了Thread和Handler。
public abstract class AsyncTask<Params, Progress, Result>
AsyncTask是一个抽象的泛型类，它提供了Params，Progress，Result三个泛型参数。Params表示参数的类型，Progress表示后台任务进度的类型，Result则表示后台任务返回结果的类型，如果不需要传递具体参数，可以用Void替代。
1.2 AsyncTask的4个核心方法
onPreExecute()
在主线程中执行,在异步任务执行之前，此方法被调用，一般可以做一些准备工作。
doInBackground(Params... params)
在线程池中执行，此方法用于执行异步任务。在此方法中可以通过调用publishProgress方法来更新任务进度，而publishProgress方法会调用onProgressUpdate，另外此方法会将结果返回给onPostExecute方法。
onProgressUpdate(Progress... values)
在主线程中执行，当在doInBackground方法中主动调用publishProgress方法时，会调用此方法。
onPostExecute(Result result)
在主线中中执行，在doInBackground方法执行完毕时，会执行该方法。
1.3 AsyncTask使用方法
创建一个AsyncTask对象，然后调用execute方法，并且这个过程必须在UI线程中进行
new AsyncTask().execute(Params... params)
1.4 AsyncTask执行过程源码分析
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
分析：在构造方法中，创建了一个异步任务，但并未执行
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;
}
分析：
1.先调用了onPreExecute方法，然后通过exec.execute(mFuture)开启异步任务
2. sDefaultExecutor是一个串行的线程池，这样会使得一个进程的所有AsyncTask任务都在这个串行池中排队执行
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@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;
}
}
}
分析：异步任务最终会调用postResult方法，并将结果通过Handler切换到主线程中去，然后调用finsh方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
分析：在finish方法中会调用onPostExecute方法，将结果从doInBackground传递给了onPostExecute，至此整个过程结束。
1.5 AsyncTask的串行和并行
//并行线程池
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();
通过源码，可以发现execute默认是串行执行的，若果想要使得异步任务并行执行，需要如下调用
new AsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,Params... params);
2. HandlerThread
2.1 介绍
HandlerThread继承自Thread，它与其他Thread的不同之处在于，在run方法中Looper.prepare()来创建消息队列，通过Looper.loop()来开启消息循环，这样就允许我们在HandlerThread中创建Handler
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
分析：通过上述代码，我们知道一个线程想要创建Handler并使用它，必须满足3个条件
1. Looper.prepare()
2. mLooper = Looper.myLooper();//用于和Handler创建关联
3. Looper.loop()
一般Thread想要使用Handler的写法如下
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}
分析：mLooper = Looper.myLooper这一步实质上在Handler的构造方法中执行了。
2.2 用法
HandlerThread ht=new HandlerThread("name");
ht.start();
Handler h=new Handler(ht.getLooper());
3. IntentService
3.1 介绍
IntentService继承自Service，它与其他Service的不同之处在于，IntentService必须要重写onHandleIntent方法，此方法在子线程，用于执行耗时任务，并且在任务执行完毕时它会自动停止服务（stopSelf(msg.arg1)），同时由于IntentService是服务的原因，它的优先级比单纯的线程要高很多，不容易被系统杀死，因此它比较适合优先级比较高的后台任务。
关于stopSelf(int startId)
当你调用stopSelf(int)，你把startID传给了对应的要停止的Service，这个startID是上一个请求的StartID！!如果没有第二个请求来，那么这个Service就会死掉，但是如果这个Service已经又接受到一个新的启动请求之后，你才调用stopSelf(int)，那么你传递给stopSelf()的ID是上一个请求的ID，而当前Service的startID已经更新为新的请求的ID，造成两个ID不对应，stopSelf()失效，那么Service就不会停止。这样就避免了将后面的请求终止。
3.2 用法
和普通Service一样，需要在xml中注册，并且通过intent，启动Service，具体代码如下
public class MyIntentService extends IntentService {
/**
* Creates an IntentService. Invoked by your subclass's constructor.
*
* @param name Used to name the worker thread, important only for debugging.
*/
public MyIntentService(String name) {
super(name);
}
@Override
protected void onHandleIntent(@Nullable Intent intent) {
//此方法在子线程中，可以执行耗时操作
}
}
//调用IntentService
Intent intent = new Intent(context, MyIntentService.class);
intent.setAction(ACTION_UPLOAD_IMG);
intent.putExtra(EXTRA_IMG_PATH, path);
context.startService(intent);
3.2 源码分析
先看看onCreate方法
public void onCreate() {
// TODO: It would be nice to have an option to hold a partial wakelock
// during processing, and to have a static startService(Context, Intent)
// method that would launch the service & hand off a wakelock.
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
分析：
当IntentService第一次启动时，它的onCreate方法被调用，onCreate方法会创建一个HandlerThread，然后使用它的Looper来构造一个Handler对象mServiceHandler，这样通过mServiceHandler发送的消息最终会在HandlerThread中执行。
每次启动IntentService时，它的onStartCommand会被调用，IntentService在onStartCommand中处理每个后台任务的Intent。而onStartCommand方法调用了onStart方法
看看onStart方法
public int onStartCommand(Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
分析：可以看出，在该方法中通过mServiceHandler发送了一个消息。这个intent参数和外界的startService(intent)中的intent内容完全一样，因此可以通过intent中传递的参数来区分不同的后台任务。
我们在来看看接受消息的一方的处理逻辑
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1);
}
}
分析：可以看出，在handleMessage中，会回调onHandleIntent方法，这个方法是抽象方法，需要子类具体去实现，这样我们就可以在该方法中通过Intent参数来执行不同的后台任务了。如果目前只有一个后台任务，那么在onHandleIntent方法执行完毕后，stopSelf(msg.arg1)就会直接停止服务（onDestroy会回调），如果目前有多个后台任务，那么当onHandleIntent的方法执行完最后一个任务时，stopSelf(msg.arg1)才会直接停止服务。
另外，需要注意的是当有多个后台任务同时存在时，这些后台任务会按照外界发起的顺序排队执行。
