AndroidService几个重要的方法运行在哪个线程

Posted 2021-08-31 Jason_Lee155

一、前言

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。