源码分析Android bindService与startService区别

android启动service，不管是bindService还是startService都不像activity那样复杂，需要创建activity的窗口，pause、resume activity等一系列生命周期操作，简单粗暴直奔ActivityManagerNative.getDefault().startService和bindService, 跟activity一样运用的是著名的binder机制，下面直接在server端，也就是ActivityManagerService直接分析他们的区别。

startservice和bindservice的区别，其中一个就是生命周期的不同

1.通过startservice开启的服务.一旦服务开启, 这个服务和开启他的调用者之间就没有任何的关系了. 
调用者不可以访问 service里面的方法. 调用者如果被系统回收了或者调用了ondestroy方法, service还会继续存在  
2.通过bindService开启的服务,服务开启之后,调用者和服务之间 还存在着联系 , 

一旦调用者挂掉了.service也会跟着挂掉 .

我们的问题是如何做到的，我们继续从源码分析。

bindService源码

public int bindService(IApplicationThread caller, IBinder token,            Intent service, String resolvedType,            IServiceConnection connection, int flags, int userId) {        enforceNotIsolatedCaller("bindService");        // Refuse possible leaked file descriptors        if (service != null && service.hasFileDescriptors() == true) {            throw new IllegalArgumentException("File descriptors passed in Intent");        }        synchronized(this) {            return mServices.bindServiceLocked(caller, token, service, resolvedType,                    connection, flags, userId);        }    }int bindServiceLocked(IApplicationThread caller, IBinder token,             Intent service, String resolvedType,            IServiceConnection connection, int flags,int userId) {          ...ConnectionRecord c = new ConnectionRecord(b, activity,                     connection, flags, clientLabel, clientIntent);             IBinder binder = connection.asBinder();             ArrayList<ConnectionRecord> clist = s.connections.get(binder);             if (clist == null) {                 clist = new ArrayList<ConnectionRecord>();                 s.connections.put(binder, clist);             }             clist.add(c);             b.connections.add(c);             if (activity != null) {                 if (activity.connections == null) {                     activity.connections = new HashSet<ConnectionRecord>();                 }                 activity.connections.add(c);             }             b.client.connections.add(c);             if ((c.flags&Context.BIND_ABOVE_CLIENT) != 0) {                 b.client.hasAboveClient = true;             }             clist = mServiceConnections.get(binder);             if (clist == null) {                 clist = new ArrayList<ConnectionRecord>();                 mServiceConnections.put(binder, clist);             }             clist.add(c);             if ((flags&Context.BIND_AUTO_CREATE) != 0) {                 s.lastActivity = SystemClock.uptimeMillis();                 if (bringUpServiceLocked(s, service.getFlags(), callerFg, false) != null) {                     return 0;                 }             }          ...}

startService源码

ComponentName startServiceLocked(IApplicationThread caller,             Intent service, String resolvedType,             int callingPid, int callingUid, int userId) {          ...    return startServiceInnerLocked(smap, service, r, callerFg, addToStarting);}ComponentName startServiceInnerLocked(ServiceMap smap, Intent service,             ServiceRecord r, boolean callerFg, boolean addToStarting) {     ...         String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false);         if (error != null) {             return new ComponentName("!!", error);         }     ...}

从源码上看，不管是bindService，还是startService,最后都调了bringUpServiceLocked，不同的是bindService之前会创建一个ConnnectionRecord对象，并保存到ConnectionRecord ArrayList中，还有

             if (activity != null) {                 if (activity.connections == null) {                     activity.connections = new HashSet<ConnectionRecord>();                 }                 activity.connections.add(c);             }

添加到ActivityRecord当中。下面我们来看unbindService究竟干了什么。

boolean unbindServiceLocked(IServiceConnection connection) {         IBinder binder = connection.asBinder();         if (DEBUG_SERVICE) Slog.v(TAG, "unbindService: conn=" + binder);         ArrayList<ConnectionRecord> clist = mServiceConnections.get(binder);         if (clist == null) {             Slog.w(TAG, "Unbind failed: could not find connection for "                   + connection.asBinder());             return false;         }         final long origId = Binder.clearCallingIdentity();         try {             while (clist.size() > 0) {                 ConnectionRecord r = clist.get(0);                 removeConnectionLocked(r, null, null);                 if (r.binding.service.app != null) {                     // This could have made the service less important.                     mAm.updateOomAdjLocked(r.binding.service.app);                 }             }         } finally {             Binder.restoreCallingIdentity(origId);         }         return true;     }

从取出对应的ConnectionRecord，然后调用removeConnectionLock，从代码上看，只是remove ConnectionRecord,跟activity生命周期没有关系，我们要找的不在这里。我们再从Activity结束来分析，Activity的生命周期主要是由ActivityStack来控制，我们发现Activity有个私有对象是mPausingActivity,activity onDestroy 时肯定会调到destroyActivityLocked。

final boolean destroyActivityLocked(ActivityRecord r,            boolean removeFromApp, boolean oomAdj, String reason) {          ...}final void cleanUpActivityLocked(ActivityRecord r, boolean cleanServices,           boolean setState) {    …}finalvoid cleanUpActivityServicesLocked(ActivityRecord r) {        // Throw away any services that have been bound by this activity.        if (r.connections != null) {            Iterator<ConnectionRecord> it = r.connections.iterator();            while (it.hasNext()) {                ConnectionRecord c = it.next();                mService.mServices.removeConnectionLocked(c, null, r);            }            r.connections = null;        }    }

最终，我们找到了，在ActivityStack cleanUpActivityServicesLocked方法中找到了答案，在activity结束之前会遍历，看是否还是ConnectionRecord，如果有，就结束它，也就解释了为什么bindService生命周期与调用者同步。