1. 初始 HandlerThread
/**
内部创建了一个线程和一个looper. 这个looper可以用来创建 Handler.
切记一定要调用start()方法
* Handy class for starting a new thread that has a looper. The looper can then be
* used to create handler classes. Note that start() must still be called.
*/
public class HandlerThread extends Thread {
Looper mLooper;
.....
}
run 方法:
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
handlerThread 和普通的 Thread 有显著的不同，它的 run 方法不是执行任务的，而是创建了 Looper ,然后调用 Looper.loop 开启了死循环。
外界需要通过Handler 的消息方式来通知 HandlerThread 执行任务。一般配合IntentService 使用。
2.IntentService
- 定义
/**
* IntentService is a base class for {@link Service}s that handle asynchronous
* requests (expressed as {@link Intent}s) on demand. Clients send requests
* through {@link android.content.Context#startService(Intent)} calls; the
* service is started as needed, handles each Intent in turn using a worker
* thread, and stops itself when it runs out of work.
*
* <p>This "work queue processor" pattern is commonly used to offload tasks
* from an application's main thread. The IntentService class exists to
* simplify this pattern and take care of the mechanics. To use it, extend
* IntentService and implement {@link #onHandleIntent(Intent)}. IntentService
* will receive the Intents, launch a worker thread, and stop the service as
* appropriate.
*
* <p>All requests are handled on a single worker thread -- they may take as
* long as necessary (and will not block the application's main loop), but
* only one request will be processed at a time.
*
* <div class="special reference">
* <h3>Developer Guides</h3>
* <p>For a detailed discussion about how to create services, read the
* <a href="{@docRoot}guide/components/services.html">Services</a> developer
* guide.</p>
* </div>
*
* @see android.os.AsyncTask
*/
public abstract class IntentService extends Service {
.....
@Override
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);
}
}
是一种特殊的 service ，继承于 service, 并且是一个抽象类。它封装了 HanlerThread 和 Handler.
通过
创建一个线程，并调用start 方法，run方法执行，里面是一个死循环，我们之前说过
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
利用thread中的looper 构建了 ServiceHandler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
服务一旦启动之后，首先调用 onCreate 刚才我们已经看了，其次就是onStartCommand ,接下来我们看下 onStartCommand 方法：
@Override
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
onStart 方法：
@Override
public void onStart(@Nullable Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
这里不错有我们在之前 onCreate 中创建的 mServiceHandler ,将startId, intent 通过 sendMessage 发送出去了。看下 mServiceHandler 的 handleMessage 方法：
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);
}
}
最终调用onHandleIntent 方法，stopSelf(startId)单个任务执行完毕尝试关闭服务 ,onHandleIntent 抽象方法，前面extend IntentService 需要实现 onHandleIntent 方法，处理不同的Intent 任务，所有任务完成后自动 onDestroy.
当单个任务执行完毕之后不会立即调用onDestroy,虽然每次都调用stopSelf(startId)
其中startId 每调用一次 startService 这个 startId 会+1
public final void stopSelf(int startId) {
if (mActivityManager == null) {
return;
}
try {
mActivityManager.stopServiceToken(
new ComponentName(this, mClassName), mToken, startId);
} catch (RemoteException ex) {
}
}
ActivityManagerService
@Override
public boolean stopServiceToken(ComponentName className, IBinder token,
int startId) {
synchronized(this) {
return mServices.stopServiceTokenLocked(className, token, startId);
}
}
boolean stopServiceTokenLocked(ComponentName className, IBinder token,
int startId) {
.....
if (r.getLastStartId() != startId) {
return false;
}
这个lastStartId 会跟随着每次startService +1,这里能看出来：
public int makeNextStartId() {
lastStartId++;
if (lastStartId < 1) {
lastStartId = 1;
}
return lastStartId;
}
}
oval
