一、引言
Service是Android中的四大组件之一，在开发中也是经常使用的。Service的用法比较简单，本文不对此进行讨论。但是，我们用了这么久的Service，是否有想过以下问题：
1、Service的几个生命周期方法是运行在哪个线程的？是主线程还是子线程？
2、当使用bindService后，ServiceConnection的回调方法onServiceConnected和onServiceDisconnected方法又是运行在哪个线程的？是主线程还是子线程？
针对上面的两个问题，本文从Android源码的角度进行解析，并给出答案。好了，下面让我们开始进入源码的世界吧！
二、Service的生命周期方法执行时所处的线程
Service的生命周期方法是onCreate、onStartCommand、onDestroy、onBind、onUnBind。
2.1、onCreate方法
首先看onCreate方法。从之前的文章【源码解析】Service的工作过程 分析知道，Service的onCreate方法是在ActivityThread的handleCreateService方法调用的，如下所示：
private void handleCreateService(CreateServiceData data) {
...省略
LoadedApk packageInfo = getPackageInfoNoCheck(
data.info.applicationInfo, data.compatInfo);
Service service = null;
try {
java.lang.ClassLoader cl = packageInfo.getClassLoader();
service = (Service) cl.loadClass(data.info.name).newInstance();
} catch (Exception e) {
...省略
}
try {
ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
context.setOuterContext(service);
Application app = packageInfo.makeApplication(false, mInstrumentation);
service.attach(context, this, data.info.name, data.token, app,
ActivityManager.getService());
service.onCreate(); //Service的onCreate方法被调用
mServices.put(data.token, service);
try {
ActivityManager.getService().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
} catch (Exception e) {
...省略
}
}
所以要确定onCreate方法的运行线程，就要确定handleCreateService方法的运行线程，可以看到handleCreateService方法是私有方法，它在H类的handleMessage方法中被调用，如下所示：
public void handleMessage(Message msg) {
switch (msg.what) {
...省略
case CREATE_SERVICE:
handleCreateService((CreateServiceData)msg.obj);
break;
...省略
}
}
所以要确定handleCreateService方法的运行线程，就有确定handleMessage方法的运行线程。由于handleMessage是H类的方法，H类是一个Handler类，所以handleMessage方法的运行线程由创建H类时的Looper对象决定。所以，我们转而找到H类创建的代码，如下所示：
final H mH = new H();
H类创建时并没有传入相关的Looper对象，所以默认的使用了其创建时的当前线程，而mH是ActivityThread的一个成员变量，所以其创建时的当前线程就是ActivityThread对象生成时的当前线程。
那么ActivityThread对象是什么时候生成的呢？ActivityThread对象是在ActivityThread的main函数中生成的，如下所示：
public static void main(String[] args) {
...省略
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
我们知道main函数是一个应用的真正入口，它是在主进程中的主线程执行的，并且之后执行一次，所以说明了ActivityThread对象创建时所处的线程是主线程。这样，我们就可以回溯证明ActivityThread的mH对象消息处理的运行线程也是主线程，最后倒推证明onCreate方法是在主线程中运行的。
2.2、其他生命周期方法
由于其他生命周期方法同样是在ActivityThread中通过mH发送消息，并由handleMessage处理的，所以它们和onCreate方法一样，也是运行在主线程。这里就不再重复分析，大家可以自己验证一下。
三、ServiceConnection的回调方法所处的线程
上面的结论告诉我们，Service的生命周期方法onBind是运行在主线程的，而onBind方法是在handleBindService方法中执行的，我们接着分析ServiceConnection的回调方法所处的线程。
3.1、onServiceConnected方法
由之前的文章【源码解析】Service的工作过程 分析知道，ServiceConnection的回调方法onServiceConnected是在onBind方法后执行的，如下所示：
private void handleBindService(BindServiceData data) {
Service s = mServices.get(data.token);
if (s != null) {
try {
data.intent.setExtrasClassLoader(s.getClassLoader());
data.intent.prepareToEnterProcess();
try {
if (!data.rebind) {
IBinder binder = s.onBind(data.intent);
ActivityManager.getService().publishService(
data.token, data.intent, binder);
} else {
s.onRebind(data.intent);
ActivityManager.getService().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
}
ensureJitEnabled();
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
} catch (Exception e) {
...省略
}
}
}
可以看到，在执行了onBind方法后，得到了该Service对象的一个句柄binder，紧接着调用了ActivityManager.getService()的publishService方法，ActivityManager.getService()是一个ActivityManagerService对象，它的publishService方法如下所示：
public void publishService(IBinder token, Intent intent, IBinder service) {
// Refuse possible leaked file descriptors
if (intent != null && intent.hasFileDescriptors() == true) {
throw new IllegalArgumentException("File descriptors passed in Intent");
}
synchronized(this) {
if (!(token instanceof ServiceRecord)) {
throw new IllegalArgumentException("Invalid service token");
}
mServices.publishServiceLocked((ServiceRecord)token, intent, service);
}
}
由于ActivityManagerService对象是在系统进程中，所以当前线程会挂起，并调用系统进程中的ActivityManagerService对象的publishService方法，而publishService方法又调用了publishServiceLocked方法，如下所示：
void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
final long origId = Binder.clearCallingIdentity();
try {
if (r != null) {
Intent.FilterComparison filter
= new Intent.FilterComparison(intent);
IntentBindRecord b = r.bindings.get(filter);
if (b != null && !b.received) {
b.binder = service;
b.requested = true;
b.received = true;
for (int conni=r.connections.size()-1; conni>=0; conni--) {
ArrayList<ConnectionRecord> clist = r.connections.valueAt(conni);
for (int i=0; i<clist.size(); i++) {
ConnectionRecord c = clist.get(i);
if (!filter.equals(c.binding.intent.intent)) {
continue;
}
try {
//这里又从系统进程回到了应用进程
c.conn.connected(r.name, service, false);
} catch (Exception e) {
...省略
}
}
}
}
serviceDoneExecutingLocked(r, mDestroyingServices.contains(r), false);
}
} finally {
Binder.restoreCallingIdentity(origId);
}
}
由之前的文章【源码解析】Service的工作过程 分析知道，c.conn.connected又从系统的服务进程回到了应用进程，并且该connected方法就是LoadApk的内部类InnerConnection的connected方法，如下所示：
private static class InnerConnection extends IServiceConnection.Stub {
final WeakReference<LoadedApk.ServiceDispatcher> mDispatcher;
InnerConnection(LoadedApk.ServiceDispatcher sd) {
mDispatcher = new WeakReference<LoadedApk.ServiceDispatcher>(sd);
}
public void connected(ComponentName name, IBinder service, boolean dead)
throws RemoteException {
LoadedApk.ServiceDispatcher sd = mDispatcher.get();
if (sd != null) {
sd.connected(name, service, dead);
}
}
}
这里继而调用了LoadedApk的ServiceDispatcher对象的connected方法，如下所示：
public void connected(ComponentName name, IBinder service, boolean dead) {
if (mActivityThread != null) {
mActivityThread.post(new RunConnection(name, service, 0, dead));
} else {
doConnected(name, service, dead);
}
}
而上面不管是调用mActivityThread对象的post方法，或者是直接调用doConnected方法，最终都会调用到doConnected方法，而这两个方法调用的doConnected方法都运行在主线程中，我们再来看doConnected方法，如下所示：
public void doConnected(ComponentName name, IBinder service, boolean dead) {
ServiceDispatcher.ConnectionInfo old;
ServiceDispatcher.ConnectionInfo info;
...省略
// If there was an old service, it is now disconnected.
if (old != null) {
mConnection.onServiceDisconnected(name);
}
if (dead) {
mConnection.onBindingDied(name);
}
// If there is a new service, it is now connected.
if (service != null) {
mConnection.onServiceConnected(name, service);
}
}
可以清晰的看到doConnected方法调用了ServiceConnection对象的onServiceConnected方法，这就是证明了onServiceConnected方法是运行在主线程的。
3.2、onServiceDisconnected方法
在doConnected方法中也同时看到了onServiceDisconnected方法会被调用，所以同时也证明了onServiceDisconnected方法是运行在主线程的。
四、总结
从源码中分析得到以下结论：Service的所有生命周期方法和ServiceConnection的回调方法都是运行在主线程的。所以在开发中特别要注意，千万不能在Service的生命周期方法中做非常耗时的操作，否则会引起主线程卡顿，严重时还会引起ANR。
