Service详解

来源：互联网发布：国内旅游消费总额数据编辑：程序博客网时间：2024/05/20 11:27

Service是一个应用程序组件，它能够在后台执行一些耗时较长的操作，并且不提供用户界面。服务能被其它应用程序的组件启动，即使用户切换到另外的应用时还能保持后台运行。此外，应用程序组件还能与服务绑定，并与服务进行交互，甚至能进行进程间通信（IPC）。比如，服务可以处理网络传输、音乐播放、执行文件I/O、或者与content provider进行交互，所有这些都是后台进行的。

服务有以下两种基本类型：

Started: 如果一个应用程序组件（比如一个activity）通过调用startService()来启动服务，则该服务就是被“started”了。一旦被启动，服务就能在后台一直运行下去，即使启动它的组件已经被销毁了。通常，started的服务执行单一的操作并且不会向调用者返回结果。比如，它可以通过网络下载或上传文件。当操作完成后，服务应该自行终止。

Bound: 如果一个应用程序组件通过调用bindService()绑定到服务上，则该服务就是被“bound”了。bound服务提供了一个客户端/服务器接口，允许组件与服务进行交互、发送请求、获取结果，甚至可以利用进程间通信（IPC）跨进程执行这些操作。绑定服务的生存期和被绑定的应用程序组件一致。多个组件可以同时与一个服务绑定，不过所有的组件解除绑定后，服务也就会被销毁。

虽然本文对这两种类型的服务是分别进行简要描述的，但是你的服务仍可以同时用两种方式工作——可以是started（一直运行下去），同时也能被绑定。只会存在一点麻烦，是否两个回调方法都要实现：实现onStartCommand()以允许组件启动服务、实现onBind()以允许绑定。

无论你的应用程序是started、bound、还是两者都支持，任何应用程序组件都可以使用此服务（即使是从另一个独立的应用程序中），同样，任何组件都可以用这种方式使用一个activity——通过一个Intent启动。不过，也可以在manifest文件中把服务声明为私有private的，以便阻止其它应用程序的访问。这将在manifest中声明服务文中详细论述。

警告：服务运行于宿主进程的主线程中——不创建自己的线程并且不是运行在单独的进程中（除非你明确指定）。这意味着，如果你的服务要执行一些很耗CPU的工作或者阻塞的操作（比如播放MP3或网络操作），你应该在服务中创建一个新的线程来执行这些工作。利用单独的线程，将减少你的activity发生应用程序停止响应（ANR）错误的风险。

1 概述
2 在manifest中声明服务
- 2.1 创建一个started服务
- 2.2 扩展IntentService类
- 2.3 扩展Service类
- 2.4 启动一个服务
- 2.5 终止一个服务
3 创建一个bound服务
4 向用户发送通知
5 在前台运行服务
6 对服务的生命周期进行管理
- 6.1 实现生命周期回调方法

概述

使用服务还是使用线程？

服务仅仅是一个组件，即使用户不再与你的应用程序发生交互，它仍然能在后台运行。因此，应该只在需要时才创建一个服务。

如果你需要在主线程之外执行一些工作，但仅当用户与你的应用程序交互时才会用到，那你应该创建一个新的线程而不是创建服务。比如，如果你需要播放一些音乐，但只是当你的activity在运行时才需要播放，你可以在onCreate()中创建一个线程，在onStart()中开始运行，然后在onStop()中终止运行。还可以考虑使用AsyncTask或HandlerThread来取代传统的Thread类。关于线程的详细信息，请参阅进程和线程。

请记住，如果你使用了服务，它默认就运行于应用程序的主线程中。因此，如果服务执行密集计算或者阻塞操作，你仍然应该在服务中创建一个新的线程来完成。

为了创建一个服务，你必须新建一个Service的子类（或一个已有Service的子类）。在你的实现代码中，请按需重写一些回调方法，用于对服务生命周期中的关键节点进行处理，以及向组件提供绑定机制。最重要的需要重写的回调方法包括：

onStartCommand()

当其它组件，比如一个activity，通过调用startService()请求started方式的服务时，系统将会调用本方法。一旦本方法执行，服务就被启动，并在后台一直运行下去。如果你的代码实现了本方法，你就有责任在完成工作后通过调用stopSelf()或stopService()终止服务。（如果你只想提供bind方式，那就不需要实现本方法。）

onBind()

当其它组件需要通过bindService()绑定服务时（比如执行RPC），系统会调用本方法。在本方法的实现代码中，你必须返回IBinder来提供一个接口，客户端用它来和服务进行通信。你必须确保实现本方法，不过假如你不需要提供绑定，那就返回null即可。

onCreate()

当服务第一次被创建时，系统会调用本方法，用于执行一次性的配置工作（之前已调用过onStartCommand()或onBind()) 了。如果服务已经运行，则本方法就不会被调用。

onDestroy()

当服务用不上了并要被销毁时，系统会调用本方法。你的服务应该实现本方法来进行资源的清理工作，诸如线程、已注册的侦听器listener和接收器receiver等等。这将是服务收到的最后一个调用。

如果组件通过调用startService()（这会导致onStartCommand()的调用）启动了服务，那么服务将一直保持运行，直至自行用stopSelf()终止或由其它组件调用stopService()来终止它。

如果组件调用bindService()来创建服务（那onStartCommand()就不会被调用），则服务的生存期就与被绑定的组件一致。一旦所有客户端都对服务解除了绑定，系统就会销毁该服务。

仅当内存少得可怜、且必须覆盖拥有用户焦点的activity的系统资源时，Android系统才会强行终止一个服务。如果服务被拥有用户焦点的activity绑定着，则它一般不会被杀死。如果服务声明为#在前台运行服务（下文讨论），则它几乎永远不会被杀死。否则，如果服务已被启动并且已运行了很长时间，那么系统将会随时间推移而降低它在后台任务列表中的级别，此类服务将很有可能会被杀死——如果服务已经启动，那你必须好好设计代码，使其能完美地应付被系统重启的情况。如果系统杀死了你的服务，只要资源再度够用，系统就会再次启动服务（当然这还取决于onStartCommand()的返回值，下文将会述及）。关于系统可能会在何时销毁服务的详细信息，请参阅进程和线程。

在下节中，你将看到如何创建每种类型的服务，以及如何在应用程序组件中使用它们。

在manifest中声明服务

与activity（及其它组件）类似，你必须在应用程序的manifest文件中对所有的服务进行声明。

要声明你的服务，把<service>元素作为子元素加入到<application>元素中去即可。例如：

<manifest ... >  ...  <application ... >      <service android:name=".ExampleService" />      ...  </application></manifest>

在<service>元素中可以包含很多其它属性，比如定义启动服务所需权限、服务运行的进程之类的属性。android:name是唯一必需的属性——它定义了服务的类名。应用程序一经发布，就不得再修改这个类名。因为这么做可能会破坏某些显式引用该服务的intent功能（参阅博客文章Things That Cannot Change）。

关于在manifest中声明服务的详情，请参阅<service>元素参考文档。

与activity一样，服务可以定义intent过滤器，使得其它组件能用隐式intent来调用服务。通过声明intent过滤器，任何安装在用户设备上的应用程序组件都有能力来启动你的服务，只要你的服务所声明的intent过滤器与其它应用程序传递给startService()的intent相匹配即可。

如果你想让服务只能内部使用（其它应用程序无法调用），那么就不必（也不应该）提供任何intent过滤器。如果不存在任何intent过滤器，那你就必须用精确指定服务类名的intent来启动服务。关于#启动一个服务的详细内容，将在下文讨论。

此外，如果包含了android:exported属性并且设置为"false"，就可以确保该服务是你应用程序的私有服务。即使服务提供了intent过滤器，本属性依然生效。

关于为服务创建intent过滤器的详细信息，请参阅Intent和Intent过滤器文档。

创建一个started服务

针对Android 1.6及以下版本

如果你正在为Android 1.6及以下版本开发应用，那么需要实现int) onStart()方法，而不是onStartCommand()（在Android 2.0中，onStart()已经过时，而用onStartCommand()取而代之）。

关于Android 2.0以前版本的兼容性信息，请参阅 onStartCommand() 文档。

started服务是指其它组件通过调用startService()来启动的服务，这会引发对该服务onStartCommand()方法的调用。

一旦服务被启动started，它就拥有了自己的生命周期，这是独立于启动它的组件的。并且它能够在后台一直运行下去，即使启动它的组件已被销毁也是如此。因此，服务应该能够在完成工作后自行终止，通过调用stopSelf()即可，或者由其它组件通过调用stopService()也可以。

诸如activity之类的应用程序组件，可以通过调用startService()启动服务,并传入一个给出了服务和服务所需数据的Intent对象。服务将在onStartCommand()方法中接收到该Intent对象。

举个例子，假定某activity需要把一些数据保存到在线数据库中。此activity可以启动一个守护服务并通过传入startService()一个intent把需要保存的数据发送给该服务。该服务在onStartCommand()内接收intent，连接Internet，再进行数据库事务处理。当事务完成后，服务自行终止，并被系统销毁。

警告：默认情况下，运行服务的进程与应用程序的相同，并且运行在应用程序的主线程中。因此，如果你的服务要执行计算密集或阻塞的操作，而同时用户又需要与同一个应用程序中的activity进行交互，那么服务将会降低activity的性能。为了避免对应用程序性能的影响，你应该在服务中启动一个新的线程。

传统做法，你可以扩展两个类来创建started服务：

Service

这是所有服务的基类。如果你要扩展该类，则很重要的一点是：请在其中创建一个新的线程来完成所有的服务工作。因为服务默认是使用应用程序的主线程的，这会降低应用程序中activity的运行性能。

IntentService

这是Service类的子类，它使用了工作（worker）线程来处理所有的启动请求，每次请求都会启动一个线程。如果服务不需要同时处理多个请求的话，这是最佳的选择。所有你要做的工作就是实现onHandleIntent()即可，它会接收每个启动请求的intent，然后就可在后台完成工作。

下一节描述了如何用这两个类来实现服务。

扩展IntentService类

因为大多数started服务都不需要同时处理多个请求（这实际上是一个危险的多线程情况），所以最佳方式也许就是用IntentService类来实现你的服务。

IntentService将执行以下步骤：

创建一个缺省的工作（worker）线程，它独立于应用程序主线程来执行所有发送到onStartCommand()的intent。

创建一个工作队列，每次向你的onHandleIntent()传入一个intent，这样你就永远不必担心多线程问题了。

在处理完所有的启动请求后，终止服务，因此你就永远不需调用stopSelf()了。

提供缺省的onBind()实现代码，它返回null。

提供缺省的onStartCommand()实现代码，它把intent送入工作队列，稍后会再传给你的onHandleIntent()实现代码。

以上所有步骤将汇成一个结果：你要做的全部工作就是实现onHandleIntent()的代码，来完成客户端提交的任务。（当然你还需要为服务提供一小段构造方法。）

以下是个IntentService的实现例程：

public class HelloIntentService extends IntentService {  /**    * 构造方法是必需的，必须用工作线程名称作为参数   * 调用父类的[http://developer.android.com/reference/android/app/IntentService.html#IntentService(java.lang.String) IntentService(String)]构造方法。   */  public HelloIntentService() {      super("HelloIntentService");  }  /**   * IntentService从缺省的工作线程中调用本方法，并用启动服务的intent作为参数。    * 本方法返回后，IntentService将适时终止这个服务。   */  @Override  protected void onHandleIntent(Intent intent) {      // 通常我们会在这里执行一些工作，比如下载文件。      // 作为例子，我们只是睡5秒钟。      long endTime = System.currentTimeMillis() + 5*1000;      while (System.currentTimeMillis() < endTime) {          synchronized (this) {              try {                  wait(endTime - System.currentTimeMillis());              } catch (Exception e) {              }          }      }  }}

所有你需要做的就是：一个构造方法和一个onHandleIntent()方法的实现。

如果你还决定重写其它的回调方法，比如onCreate()、onStartCommand()、onDestroy()，请确保调用一下父类的实现代码，以便IntentService能正确处理工作线程的生命周期。

比如说，onStartCommand()必须返回缺省实现代码的结果（缺省代码实现了如何获取传给onHandleIntent()的intent）：

@Overridepublic int onStartCommand(Intent intent, int flags, int startId) {    Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();    return super.onStartCommand(intent,flags,startId);}

除了onHandleIntent()以外，唯一不需要调用父类实现代码的方法是onBind()（不过如果你的服务允许绑定，你还是需要实现它）。

在下一节中，你将看到如何扩展Service基类来实现同一服务，代码量会多一些，但可能适合处理多个同时发起的请求。

扩展Service类

如上节所述，利用IntentService来实现一个started服务非常简单。不过，假如你的服务需要多线程运行（而不是通过一个工作队列来处理启动请求），那你可以扩展Service类来完成每个intent的处理。

作为对照，以下例程实现了 Service 类，它执行的工作与上述使用IntentService的例子相同。确切地说，对于每一个启动请求，它都用一个工作线程来完成处理工作，并且每次只处理一个请求。

public class HelloService extends Service {  private Looper mServiceLooper;  private ServiceHandler mServiceHandler;  // 处理从线程接收的消息  private final class ServiceHandler extends Handler {      public ServiceHandler(Looper looper) {          super(looper);      }      @Override      public void handleMessage(Message msg) {          // 通常我们在这里执行一些工作，比如下载文件。          // 作为例子，我们只是睡个5秒钟。          long endTime = System.currentTimeMillis() + 5*1000;          while (System.currentTimeMillis() < endTime) {              synchronized (this) {                  try {                      wait(endTime - System.currentTimeMillis());                  } catch (Exception e) {                  }              }          }          // 根据startId终止服务，这样我们就不会在处理其它工作的过程中再来终止服务          stopSelf(msg.arg1);      }  }  @Override  public void onCreate() {    // 启动运行服务的线程。    // 请记住我们要创建一个单独的线程，因为服务通常运行于进程的主线程中，可我们不想阻塞主线程。    // 我们还要赋予它后台运行的优先级，以便计算密集的工作不会干扰我们的UI。    HandlerThread thread = new HandlerThread("ServiceStartArguments",            Process.THREAD_PRIORITY_BACKGROUND);    thread.start();        // 获得HandlerThread的Looper队列并用于Handler    mServiceLooper = thread.getLooper();    mServiceHandler = new ServiceHandler(mServiceLooper);  }  @Override  public int onStartCommand(Intent intent, int flags, int startId) {      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();      // 对于每一个启动请求，都发送一个消息来启动一个处理      // 同时传入启动ID，以便任务完成后我们知道该终止哪一个请求。      Message msg = mServiceHandler.obtainMessage();      msg.arg1 = startId;      mServiceHandler.sendMessage(msg);            // 如果我们被杀死了，那从这里返回之后被重启      return START_STICKY;  }  @Override  public IBinder onBind(Intent intent) {      // 我们不支持绑定，所以返回null      return null;  }    @Override  public void onDestroy() {    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();   }}

如你所见，它要干的事情比用IntentService时多了很多。

不过，因为是自行处理每个onStartCommand()调用，你可以同时处理多个请求。本例中没有这么去实现，但只要你愿意，你就可以为每个请求创建一个新的线程，并立即运行它们（而不是等待前一个请求处理完毕）。

请注意onStartCommand()方法必须返回一个整数。这个整数是描述系统在杀死服务之后应该如何继续运行（上一节中缺省的 IntentService 实现代码会替你处理这一点，当然那样你就无法修改这个处理过程）。onStartCommand()的返回值必须是以下常量之一：

START_NOT_STICKY: 如果系统在onStartCommand()返回后杀死了服务，则不会重建服务了，除非还存在未发送的intent。当服务不再是必需的，并且应用程序能够简单地重启那些未完成的工作时，这是避免服务运行的最安全的选项。

START_STICKY: 如果系统在onStartCommand()返回后杀死了服务，则将重建服务并调用onStartCommand()，但不会再次送入上一个intent，而是用null intent来调用onStartCommand() 。除非还有启动服务的intent未发送完，那么这些剩下的intent会继续发送。这适用于媒体播放器（或类似服务），它们不执行命令，但需要一直运行并随时待命。

START_REDELIVER_INTENT: 如果系统在onStartCommand()返回后杀死了服务，则将重建服务并用上一个已送过的intent调用onStartCommand()。任何未发送完的intent也都会依次送入。这适用于那些需要立即恢复工作的活跃服务，比如下载文件。

关于这些返回值的详情，请参阅每个常量的参考文档链接。

启动一个服务

从activity或其它应用程序组件中可以启动一个服务，调用startService()并传入一个Intent（指定所需启动的服务）即可。Android系统将调用服务的onStartCommand()方法，并传入该Intent（你永远都不应该直接去调用onStartCommand()。）

例如，一个activity可以用一个显式的intent通过startService()启动上一节的示例服务（HelloSevice）：

Intent intent = new Intent(this, HelloService.class);startService(intent);

startService()方法会立即返回，Android系统会去调用服务的onStartCommand() 方法。如果服务还未运行，系统会首先调用onCreate()，然后再去调用onStartCommand() 。

如果服务不同时支持绑定，那么通过startService()传入的intent将是应用程序组件与服务进行交互的唯一途径。当然，如果你期望服务能返回结果，那启动服务的客户端可以创建一个PendingIntent来获得一个广播broadcast（利用getBroadcast()），并把它放入启动服务的Intent并传到服务中去。然后服务就会用这个broadcast来传递结果。

多个启动服务的请求将会引发服务onStartCommand()方法的多次调用。不过，只有一个终止服务的请求（用stopSelf()或stopService()）会被接受并执行。

终止一个服务

一个started服务必须自行管理生命周期。也就是说，系统不会终止或销毁这类服务，除非必须恢复系统内存并且服务返回后一直维持运行。因此，服务必须通过调用stopSelf()自行终止，或者其它组件可通过调用stopService()来终止它。

用stopSelf()或stopService()的终止请求一旦发出，系统就会尽快销毁服务。

不过，如果你的服务要同时处理多个onStartCommand()请求，那在处理启动请求的过程中，你就不应该去终止服务，因为你可能接收到了一个新的启动请求（在第一个请求处理完毕后终止服务将停止第二个请求的处理。为了避免这个问题，你可以用stopSelf(int)来确保终止服务的请求总是根据最近一次的启动请求来完成。也就是说，当你调用stopSelf(int) 时，你把启动请求ID（发送给onStartCommand()的startId）传给了对应的终止请求。这样，如果服务在你可以调用stopSelf(int)时接收到了新的启动请求，则ID将会不一样，服务将不会被终止。

警告：当服务完成工作后，你的应用程序应该及时终止它，这点非常重要。这样可以避免系统资源的浪费，并能节省电池的电力。必要时，其它组件可以通过调用stopService()来终止服务。即使你的服务允许绑定，你也必须保证它在收到对onStartCommand()的调用时能够自行终止。

关于服务生命周期的详细信息，请参阅下文的#对服务的生命周期进行管理章节。

创建一个bound服务

bound服务是指允许被应用程序组件绑定的服务，通过调用bindService()可以完成绑定，用于创建一个长期存在的连接（并且一般不再允许组件通过调用startService()来start服务。

当应用程序中的activity或其它组件需要与服务进行交互，或者应用程序的某些功能需要暴露给其它应用程序时，你应该创建一个bound服务，并通过进程间通信（IPC）来完成。

要创建一个bound服务，你必须实现onBind()回调方法，并返回一个IBinder对象，此对象定义了与服务进行通信的接口。然后，其它应用程序组件可以调用bindService()来获得接口并调用服务中的方法。服务只在为绑定的应用程序组件工作时才会存活，因此，只要没有组件绑定到服务，系统就会自动销毁服务（你不需要像started服务中那样通过onStartCommand()来终止一个bound服务）。

要创建一个bound服务，首先必须定义好接口，用于指明客户端如何与服务进行通信。这个客户端与服务之间的接口必须是一个IBinder对象的实现，并且你的服务必须在onBind()回调方法中返回这个对象。一旦客户端接收到这个IBinder，它就可以通过这个接口来与服务进行交互。

同一个服务可以被多个客户端绑定。当客户端完成交互时，会调用unbindService()来解除绑定。一旦不存在客户端与服务绑定时，系统就会销毁该服务。

实现bound服务的方式可以有很多种，实现的过程也比started类型的服务更为复杂，因此bound服务将在单独的bound服务文档中讨论。

向用户发送通知

一旦开始运行，服务就能够利用toast通知或状态栏通知把事件通知给用户。

toast通知是一个显示在当前窗口之上的消息框，显示一会儿之后它会自行消失。而状态栏通知则是在状态栏上显示一个附带消息的图标，用户可以选中它来执行一个action（比如启动一个activity）。

通常，当某些后台工作已经完成时（比如文件下载完毕），状态栏通知是最好的通知手段，用户这时可以在其上执行一些操作。

详情请参阅toast通知或状态栏通知开发指南。

在前台运行服务

前台服务是指那些经常会被用户关注的服务，因此内存过低时它不会成为被杀的对象。前台服务必须提供一个状态栏通知，并会置于“正在进行的”（“Ongoing”）组之下。这意味着只有在服务被终止或从前台移除之后，此通知才能被解除。

例如，用服务来播放音乐的播放器就应该运行在前台，因为用户会清楚地知晓它的运行情况。状态栏通知可能会标明当前播放的歌曲，并允许用户启动一个activity来与播放器进行交互。

要把你的服务请求为前台运行，可以调用startForeground()方法。此方法有两个参数：唯一标识通知的整数值、状态栏通知Notification对象。例如：

Notification notification = new Notification(R.drawable.icon, getText(R.string.ticker_text),        System.currentTimeMillis());Intent notificationIntent = new Intent(this, ExampleActivity.class);PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);notification.setLatestEventInfo(this, getText(R.string.notification_title),        getText(R.string.notification_message), pendingIntent);startForeground(ONGOING_NOTIFICATION, notification);

要从前台移除服务，请调用stopForeground()方法，这个方法接受个布尔参数，表示是否同时移除状态栏通知。此方法不会终止服务。不过，如果服务在前台运行时被你终止了，那么通知也会同时被移除。

注意：startForeground()和stopForeground()方法是自Android 2.0 (API Level 5)开始引入的。为了让服务能在更早版本的平台上实现前台运行，你必须使用以前的setForeground()方法——关于如何提供向后兼容性的详情，请参阅startForeground()。

有关通知的详细信息，请参阅创建状态栏通知。

对服务的生命周期进行管理

服务的生命周期与activity的非常类似。不过，更重要的是你需密切关注服务的创建和销毁环节，因为后台运行的服务是不会引起用户注意的。

服务的生命周期——从创建到销毁——可以有两种路径：

一个started服务

这类服务由其它组件调用startService()来创建。然后保持运行，且必须通过调用stopSelf()自行终止。其它组件也可通过调用stopService() 终止这类服务。服务终止后，系统会把它销毁。

一个bound服务

服务由其它组件（客户端）调用bindService()来创建。然后客户端通过一个IBinder接口与服务进行通信。客户端可以通过调用unbindService()来关闭联接。多个客户端可以绑定到同一个服务上，当所有的客户端都解除绑定后，系统会销毁服务。（服务不需要自行终止。）

这两条路径并不是完全隔离的。也就是说，你可以绑定到一个已经用startService()启动的服务上。例如，一个后台音乐服务可以通过调用startService()来启动，传入一个指明所需播放音乐的 Intent。之后，用户也许需要用播放器进行一些控制，或者需要查看当前歌曲的信息，这时一个activity可以通过调用bindService()与此服务绑定。在类似这种情况下，stopService()或stopSelf()不会真的终止服务，除非所有的客户端都解除了绑定。

实现生命周期回调方法

publicclassExampleServiceextendsService{与activity类似，服务也存在生命周期回调方法，你可以实现这些方法来监控服务的状态变化，并在适当的时机执行一些操作。以下代码提纲展示了服务的每个生命周期回调方法：

    int mStartMode;       // 标识服务被杀死后的处理方式    IBinder mBinder;      // 用于客户端绑定的接口    boolean mAllowRebind; // 标识是否使用onRebind    @Override    public void onCreate() {        // 服务正被创建    }    @Override    public int onStartCommand(Intent intent, int flags, int startId) {        // 服务正在启动，由startService()调用引发        return mStartMode;    }    @Override    public IBinder onBind(Intent intent) {        // 客户端用bindService()绑定服务        return mBinder;    }    @Override    public boolean onUnbind(Intent intent) {        // 所有的客户端都用unbindService()解除了绑定        return mAllowRebind;    }    @Override    public void onRebind(Intent intent) {        // 某客户端正用bindService()绑定到服务,        // 而onUnbind()已经被调用过了    }    @Override    public void onDestroy() {        // 服务用不上了，将被销毁    }}

注意：与activity的生命周期回调方法不同，你不是一定要调用父类的回调方法。

通过实现这些方法，你能够监控服务中两个嵌套的生命周期循环

服务的完整生存期开始于onCreate()调用时，结束于onDestroy()返回时。与activity类似，服务在onCreate()中完成初始设置工作，并在onDestroy()中释放所有未释放的资源。例如，一个音乐播放服务可以在onCreate()中创建音乐播放线程，而在onDestroy()中终止该线程。不管是用startService()创建的，还是用bindService()创建的，所有的服务都会调用onCreate()和onDestroy()方法。

服务的活跃生存期开始于onStartCommand()或onBind()的调用。这两个方法分别会传入传给startService()或bindService()的 Intent。如果服务是started的，则活跃生存期与完整生存期同时结束（即使onStartCommand()返回后，服务仍然处于活跃期。）如果服务是bound的，则活跃生存期在 onUnbind() 返回后结束。

注意：虽然started的服务是用stopSelf()或stopService()调用来终止的，但是服务却没有相应的回调方法（不存在onStop()回调方法）。因此，除非服务与客户端绑定了，不然系统就会在服务终止时销毁它——onDestroy()是唯一会收到的回调方法。

图 2 标明了服务中典型的回调方法。尽管此图把startService()创建的服务和bindService()创建的分开描述了，但请记住，无论启动的方式如何，所有的服务实际上都允许被绑定。因此，用onStartCommand()启动的服务（客户端调用startService()）仍然可以接收onBind()调用（当客户端调用了bindService()时）。

有关创建支持绑定的服务，详情请参阅bound服务文档，在其中的bound服务#管理bound服务的生命周期章节中包含了有关onRebind()回调方法的详细信息。

1 0