在开始这篇文章前,我们先来讨论以下几个问题
问题:
- 子线程中可不可以像主线程一样具有消息循环?【子线程常驻】【prepare loop】
- 主线程是如何往子线程中发消息的?【防止主线程阻塞】【HandlerThread】
- 子线是如何往主线程发消息的?【更新UI】【HandlerThread】
- HandlerThread的使用,AsyncTask的实现原理。
1.子线程中可不可以像主线程一样具有消息循环?
public final class ActivityThread { // 新建一个类,使他常驻不退出
......
public static final void main(String[] args) {
......
Looper.prepareMainLooper(); // 调用此方法,只有在主线程调用prepareMainLooper()函数,子线程只能用prepare()函数
......
ActivityThread thread = new ActivityThread();
thread.attach(false);
......
Looper.loop(); // 进入loop
......
thread.detach();
......
}
......
}
// 通过以上prepareMainLooper()或者prepare()函数与loop()函数的调用即可保证main()方法常驻不退出
// 接下来看一下prepareMainLooper()或者prepare()的异同
public class Looper {
......
// sThreadLocal.get() will return null unless you've called prepare().
private static final ThreadLocal sThreadLocal = new ThreadLocal();
public static final void prepare() { // 保证sThreadLocal中只有一个Looper,在子线程中调用
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created perthread");
}
sThreadLocal.set(new Looper());
}
......
public static final Looper myLooper() {//获取sThreadLocal中的Looper
return (Looper)sThreadLocal.get();
}
......
public static final void prepareMainLooper() { // 在主线程中调用
prepare();//先调用prepare,然后设置mMainLooper
setMainLooper(myLooper());
......
}
......
private static Looper mMainLooper = null;//主线程的looper
......
private synchronized static void setMainLooper(Looper looper) {
mMainLooper = looper;
}
public synchronized static final Looper getMainLooper() {
return mMainLooper;
}
......
}
2.主线程是如何往子线程中发消息的
// HandlerThread 的实现
public class HandlerThread extends Thread {
......
private Looper mLooper;
public HandlerThread(String name) {
super(name);
......
}
......
public void run() {
......
Looper.prepare();//注意此处是子线程,只有在子线程中才使用prepare()
synchronized (this) {
mLooper = Looper.myLooper();//子线程的mLooper实例化
......
}
......
Looper.loop();
......
}
public Looper getLooper() {
......
return mLooper;
}
......
}
// 此处是android源码中 加载APPS 的过程,子线是如何往主线程发消息的
public class LauncherModel extends BroadcastReceiver {
......
private LoaderTask mLoaderTask;
private static final HandlerThread sWorkerThread = new HandlerThread("launcher-loader");//创建一个HandlerThread线程
static {
sWorkerThread.start();//启动HandlerThread线程
}
//用HandlerThread线程的Looper创建一个Handler,即这个handler即可往HandlerThread中发消息
private static final Handler sWorker = new Handler(sWorkerThread.getLooper());
......
public void startLoader(Context context, boolean isLaunching) {
......
synchronized (mLock) {
......
// Don't bother to start the thread if we know it's not going to do anything
if (mCallbacks != null && mCallbacks.get() != null) {
......
mLoaderTask = new LoaderTask(context, isLaunching);//创建一个线程mLoaderTask
sWorker.post(mLoaderTask);//往子线程中发一个消息,将线程mLoaderTask放入到子线程中去执行
}
}
}
......
private class LoaderTask implements Runnable {//定义一个线程类
......
public void run() {
......
keep_running: {
......
// second step
if (loadWorkspaceFirst) {
......
loadAndBindAllApps();//加载全部apk
} else {
......
}
......
}
......
}
......
}
......
}
3.AsyncTask的实现原理
public abstract class AsyncTask {
......
private static final BlockingQueue sWorkQueue = new LinkedBlockingQueue(10);//工作任务队列
private static final ThreadFactory sThreadFactory = new ThreadFactory() {//用来创建线程池中的线程
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());//创建线程
}
};
//创建线程池sExecutor,核心线程数CORE_POOL_SIZE,最大线程数MAXIMUM_POOL_SIZE
//当线程池中线程数大于核心线程数时 空闲时间超过KEEP_ALIVE的线程将被回收,
//KEEP_ALIVE的单位TimeUnit.SECONDS, 工作任务队列sWorkQueue, 线程工厂sThreadFactory
private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);
//创建三种消息以及创建一个主线程的Handler对象
private static final int MESSAGE_POST_RESULT = 0x1;
private static final int MESSAGE_POST_PROGRESS = 0x2;
private static final int MESSAGE_POST_CANCEL = 0x3;
private static final InternalHandler sHandler = new InternalHandler();
private final WorkerRunnable mWorker;
private final FutureTask mFuture;//构造时需要用到WorkerRunnable对象,执行时会调用WorkerRunnable对象的call函数,执行完后会调用done函数
......
public AsyncTask() {
//实例化mWorker对象【Callable的子类WorkerRunnable的对象】
mWorker = new WorkerRunnable() {
public Result call() throws Exception {//回调函数中调用doInBackground(mParams)
......
return doInBackground(mParams);//mParams是从AsyncTask对象的execute函数传进来的参数列表
}
};
//实例化mFuture对象【Runnable的子类FutureTask的对象】 可以作为一个任务来运行
mFuture = new FutureTask(mWorker) {//传入mWorker对象
@Override
protected void done() {//mWorker执行完成后会调用done方法??????
Message message;
Result result = null;
try {
result = get();
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
message = sHandler.obtainMessage(MESSAGE_POST_CANCEL, new AsyncTaskResult(AsyncTask.this, (Result[]) null));
message.sendToTarget();
return;
} catch (Throwable t) {
throw new RuntimeException("An error occured while executing " + "doInBackground()", t);
}
//将运行结果AsyncTaskResult封装为Message对象,然后通过消息处理器sHandler加入到主线程的消息队列中
message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult(AsyncTask.this, result));
message.sendToTarget();
}
};
}
......
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
......
public final AsyncTask execute(Params... params) {
......
mWorker.mParams = params;//保存execute函数传入的参数列表
sExecutor.execute(mFuture);//执行子线程任务mFuture
return this;
}
......
protected final void publishProgress(Progress... values) {//在doInBackground中调用这个函数,则可以将values封装为消息发送到主线程队列里面。
sHandler.obtainMessage(MESSAGE_POST_PROGRESS,new AsyncTaskResult(this, values)).sendToTarget();
}
private void finish(Result result) {
......
onPostExecute(result);
......
}
......
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]);//将会调用onPostExecute函数
break;
case MESSAGE_POST_PROGRESS://处理publishProgress函数传递过来的值
result.mTask.onProgressUpdate(result.mData);
break;
case MESSAGE_POST_CANCEL:
result.mTask.onCancelled();
break;
}
}
}
private static abstract class WorkerRunnable implements Callable {
Params[] mParams; //用于保存从AsyncTask对象的execute函数传进来的参数列表
}
private static class AsyncTaskResult {
final AsyncTask mTask;//创建的AsyncTask的对象
final Data[] mData;//任务执行的结果
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
}