IntentService从源码解析

子线程的生命周期就是run方法结束了就结束了,这个我要说的一点就是HandlThread类,这里是由于quene.next()一直监听着消息队列,处于堵塞状态,所以这个线程是创建了就一直存在的。案例说安卓的主线程run方法执行完了也就该退出,由于安卓的主线程是一个特殊的线程所以一直存在。
IntentService从源码解析_第1张图片
IntentService从源码解析_第2张图片
下面我们看下曾经写过的一个主线程给子线程的发送的案例
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
handler = new Handler(){
@Override
public void handleMessage(Message msg) {
Toast.makeText(MainActivity.this,msg.toString(), Toast.LENGTH_LONG).show();
}
};
Looper.loop();

        }
    });
    thread.start();

}
public void click(View view){
    handler.obtainMessage(2, "主线程给子线程发送消息").sendToTarget();
}

这里的子线程就是通过looper. loop()一直一直监听消息队列处于堵塞状态,所以这个线程也是一直存在的,所以导致内存泄漏的问题,一般来说,我们不不能够这样子用的,除非我们需要某个线程一直存在从消息队列里拿东西,那样我们会使用这种做法,有个HandlerThread类大概就是使用了这一原理。

下面我们来通过源码追究一下HandlerThread是个什么东西?
HanlderThread其实就是一个Thread,继承了Thread的一个类,一般线程都是run方法执行结束的话就应该结束了,但是HandlerThread内部通过创建Looper.Prepared()创建消息队列,通过Looper.Loop()开启消息循环,由于消息循环是一个堵塞的死循环,所以这个消息队列一直存在着,可以执行耗时的任务,由于这是个无限循环的,所以我们明确的想要关闭的话,可以使用quit,或者quitSafely();
下面我们追源码看看这个quit都做了什么?
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
追进去发现
quit方法
public void quit() {
mQueue.quit(false);
}
quitSafely方法
public void quitSafely() {
mQueue.quit(true);
}
以上两个方法都是调用了 MessageQueue 的quit方法,下面我们看下MessageQueen中的两个方法差别在哪?
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new RuntimeException(“Main thread not allowed to quit.”);
}
synchronized (this) {
if (mQuiting) {
return;
}
mQuiting = true;
if (safe) {
removeAllFutureMessagesLocked();//清空延迟消息,将消息池中的非延迟消息派发出去由handler处理
} else {
removeAllMessagesLocked();//清空里面所有的消息,不论延迟还是非延迟的
}
}
nativeWake(mPtr);
}
quitSafely相比quit方法的安全之处在于在清空消息之前会派发所有的非延迟消息。
无论是调用了quit方法还是quitSafely方法只会,Looper就不再接收新的消息。即在调用了Looper的quit或quitSafely方法之后,消息循环就终结了,这时候再通过Handler调用sendMessage或post等方法发送消息时均返回false,表示消息没有成功放入消息队列MessageQueue中,因为消息队列已经退出了。

这么就是说在调用quit方法之后消息队列关闭了,所以这样就不存在消息堵塞机制了,那么线程的run方法就可以结束啦。

当我们开启一个Intentservice的时候会传入一个intent值。
}
public void click3(View v){

    Intent service=new Intent(this, Myintentservice.class);
    service.putExtra("a", "第三次开启intentService");
    startService(service);
}

其实intentService的核心就是在于在他的Oncreate()方法中我们创建了一个HandlerHtread,然后把这个Thread传进一个ServiceHandler 构造方法里面,这样这个ServiceHandler 发送的消息都是在这个Handler中执行的。onstart()方法恰恰就是把开启service传进来的intent值发送到ServiceHandler中

IntentService内部类
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);
}
}
IntentService是把onHandleIntent抽象出去让子类去实现的
protected abstract void onHandleIntent(Intent intent);

看到这个stopSelf方法了吗,这个就是当onHandleIntent方法执行完了以后IntentService会通过stopSelf(int id)终止服务,为什么用stopSelf()是因为这个是立刻终止服务,而带参数的这个是待消息执行完才终止服务。

我们看看oncreate,onstart
@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);
}
@Override
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}

由于Handler中Loop中的MessageQueen中的任务都是按照顺序执行的,所以intentService中的任务也是按照顺序执行的。

你可能感兴趣的:(线程,sercice)