Android Activity的生命周期

一、为什么要了解Activity的生命周期

• activity is directly affected by its association withother activities, its task and back stack.

• 翻：对于开发一个强大和灵活的应用程序，实现Activity的回调方法来管理Activity的生命周期至关重要。
• 一个Activity的生命周期直接影响与它结合的其他Activitys和它的任务返回堆栈。

二、Activity生命周期的表现

除了我们自行启动（start）或者结束（finish）一个Activity，我们并不能直接控制一个Activity 的生命状态，我们只能通过实现Activity生命状态的表现——即回调方法来达到管理Activity生命周期的变化。

具体如下图所示：

通过上图，我们可以看到这些方法定义了Activity整个生命周期。

为什么要定义这么多生命周期的方法呢？最主要的目的就是把Activity的各个不同的状态区分处理。

通过实施这些方法,您可以监视Activity生命周期中的三个嵌套循环：

1、entire lifetime （整个生命周期）

一个Activity整个生命周期，存在于onCreate()方法和onDestroy()调用之间。你的Activity应该在onCreate()方法里执行设置“全局”状态(如定义布局)。并在onDestroy()方法里释放所有剩余资源。例如，如果你的活动有一个线程在后台运行下载网络数据，它可以在onCreate()中创建该线程，然后在onDestroy()中停止线程。

2、visible lifetime（可见生命周期）

一个Activity可见生命周期，存在于onStart()和onStop()调用之间。在此期间，用户可以看到屏幕上的activity并与之交互。当一个其他的Activity启动，并且这个Activity完全不可见的时候，onStop()方法就会被调用。在这两个方法，你可以保持该Activity需要展示给用户的资源。例如，您可以在onStart()方法里注册一个BroadcastReceiver来监控你的UI的变化，并在onStop()方法里注销它。在整个生命周期的活动中，系统可能会调用onStart()和onStop()多次，因为活动之间交替进行隐藏或显示给用户。

3、 foreground lifetime（前台生命周期）

一个Activity前台生命周期，存在于onResume()和onPause()调用之间。在这段时间里，这个Activity在其他所有Activity的前面，拥有用户输入焦点。一个Activity可以经常在前台状态发生转换—比如，当设备休眠或者弹出了个对话框。因为经常会发生转换，class LifecycleActivity extends Activity {

• private Button mBtn1;
• @Override
• public void onCreate(Bundle savedInstanceState) {
• super.onCreate(savedInstanceState);
• System.out.println("LifecycleActivity onCreate");
• setContentView(R.layout.life_cycle_activity);
• mBtn1 = (Button) findViewById(R.id.btn1);
• mBtn1.setOnClickListener(new View.OnClickListener() {
• public void onClick(View v) {
• finish();
• }
• });
• }
• @Override
• protected void onStart() {
• super.onStart();
• System.out.println("LifecycleActivity onStart");
• }
• @Override
• protected void onResume() {
• super.onResume();
• System.out.println("LifecycleActivity onResume");
• }
• @Override
• protected void onPause() {
• super.onPause();
• System.out.println("LifecycleActivity onPause");
• }
• @Override
• protected void onStop() {
• super.onStop();
• System.out.println("LifecycleActivity onStop");
• }
• @Override
• protected void onDestroy() {
• super.onDestroy();
• System.out.println("LifecycleActivity onDestroy");
• }
• @Override
• protected void onRestart() {
• super.onRestart();
• System.out.println("LifecycleActivity onRestart");
• }
• }

当进入这个Activity时，打印如下：

当点击按钮，调用finish()方法后，打印如下：

如果我们将finish()调用直接放在onCreate方法里，那么打印如下：

如果我们将finish()调用直接放在onStart方法里，那么打印如下：

如果我们将finish()调用直接放在onResume方法里，那么打印如下：

如上图的结果，所以很多人喜欢把Activity的生命周期表示为一种对称的结构：

2、Activity之间切换时生命周期的变化

1、基本的变化

现在有两个Activity，LifecycleActivity和LifecycleOtherActivity，都重写了所有的生命周期方法，并加上了打印输出。

进入第一个Activity——LifecycleActivity，打印如下：

1. 06-07 23:16:31.389: I/System.out(1341): LifecycleActivity onCreate
2. 06-07 23:16:31.455: I/System.out(1341): LifecycleActivity onStart
3. 06-07 23:16:31.455: I/System.out(1341): LifecycleActivity onResume

一个Activity的创建，没什么可说的。

在LifecycleActivity中有一个按钮，点击事件为

1. public void onClick(View v) {
2. startActivity(new Intent(LifecycleActivity.this, LifecycleOtherActivity.class));
3. }

点击该按钮，打印如下：

1. 06-07 23:40:40.545: I/System.out(1409): LifecycleActivity onPause
2. 06-07 23:40:40.585: I/System.out(1409): LifecycleOtherActivity onCreate
3. 06-07 23:40:40.585: I/System.out(1409): LifecycleOtherActivity onStart
4. 06-07 23:40:40.585: I/System.out(1409): LifecycleOtherActivity onResume
5. 06-07 23:40:41.176: I/System.out(1409): LifecycleActivity onStop

启
动一个全屏显示的LifecycleOtherActivity，前面的LifecycleActivity肯定是要Stopped，但是这个调用的顺序
一定要注意。它是先onPause，然后等LifecycleOtherActivity执行完onResume方法后，在执行的onStop方法。这也
是为什么强调在onPause方法里面，我们只能去执行一些轻量级的代码。

现在LifecycleOtherActivity处于前台，并拥有用户焦点，现在点击返回按钮，打印如下：

1. 06-07 23:47:21.796: I/System.out(1508): LifecycleOtherActivity onPause
2. 06-07 23:47:21.815: I/System.out(1508): LifecycleActivity onRestart
3. 06-07 23:47:21.815: I/System.out(1508): LifecycleActivity onStart
4. 06-07 23:47:21.815: I/System.out(1508): LifecycleActivity onResume
5. 06-07 23:47:22.295: I/System.out(1508): LifecycleOtherActivity onStop
6. 06-07 23:47:22.295: I/System.out(1508): LifecycleOtherActivity onDestroy

按下返回按钮，相当于finish掉了LifecycleOtherActivity，看它的执行过程，也是先暂停自身，然后再去重启LifecycleActivity，等LifecycleActivity重启完毕后，在调用onStop和onDestory方法。

2、启动对话框样式的Activity

现在有两个Activity，LifecycleActivity和LifecycleDialogActivity（对话框样式的Activity），都重写了所有的生命周期方法，并加上了打印输出。

进入第一个Activity——LifecycleActivity，打印如下：

1. 06-07 23:16:31.389: I/System.out(1341): LifecycleActivity onCreate
2. 06-07 23:16:31.455: I/System.out(1341): LifecycleActivity onStart
3. 06-07 23:16:31.455: I/System.out(1341): LifecycleActivity onResume

一个Activity的创建，没什么可说的。

在LifecycleActivity中有一个按钮，点击事件为

1. public void onClick(View v) {
2. startActivity(new Intent(LifecycleActivity.this, LifecycleDialogActivity.class));
3. }

点击该按钮，打印如下：

1. 06-08 00:01:04.245: I/System.out(1508): LifecycleActivity onPause
2. 06-08 00:01:04.325: I/System.out(1508): LifecycleDialogActivity onCreate
3. 06-08 00:01:04.325: I/System.out(1508): LifecycleDialogActivity onStart
4. 06-08 00:01:04.325: I/System.out(1508): LifecycleDialogActivity onResum

启动一个对话框样式的LifecycleDialogActivity，并不会调用onStop方法

现在LifecycleDialogActivity处于前台，并拥有用户焦点，现在点击返回按钮，打印如下：

1. 06-08 00:02:05.535: I/System.out(1508): LifecycleDialogActivity onPause
2. 06-08 00:02:05.625: I/System.out(1508): LifecycleActivity onResume
3. 06-08 00:02:06.165: I/System.out(1508): LifecycleDialogActivity onStop
4. 06-08 00:02:06.165: I/System.out(1508): LifecycleDialogActivity onDestroy

可以看到在LifecycleDialogActivity暂停之后，之前调用的是LifecycleActivity的onResume方法。

3、启动一个普通的对话框？

在LifecycleActivity中有一个按钮，点击事件为

1. public void onClick(View v) {
2. AlertDialog.Builder builder = new AlertDialog.Builder(LifecycleActivity.this);
3. builder.setTitle("我是一个对话框").setPositiveButton("确定", null);
4. builder.create().show();
5. }

点击该按钮，可以发现，没有发现任何打印，也就是LifecycleActivity的生命周期没有任何改变。

4、LifecycleActivity中按钮的点击事件改成如下，并重写finish和startActivity，在里面也增加打印输出。

1. mBtn.setOnClickListener(new View.OnClickListener() {
2. public void onClick(View v) {
3. finish();
4. startActivity(new Intent(LifecycleActivity.this, LifecycleOtherActivity.class));
5. System.out.println("ABCDEFG");
6. }
7. });

点击改按钮，打印如下：

1. 06-08 22:07:26.599: I/System.out(560): LifecycleActivity finish
2. 06-08 22:07:26.619: I/System.out(560): LifecycleActivity startActivity
3. 06-08 22:07:26.619: I/System.out(560): ABCDEFG
4. 06-08 22:07:26.619: I/System.out(560): LifecycleActivity onPause
5. 06-08 22:07:26.671: I/System.out(560): LifecycleOtherActivity onCreate
6. 06-08 22:07:26.671: I/System.out(560): LifecycleOtherActivity onStart
7. 06-08 22:07:26.671: I/System.out(560): LifecycleOtherActivity onResume
8. 06-08 22:07:27.510: I/System.out(560): LifecycleActivity onStop
9. 06-08 22:07:27.510: I/System.out(560): LifecycleActivity onDestroy

这
里面涉及到Activity的管理问题，没有太多的研究，不太清楚，不过大概可以理解为finish和startActivity都是一个异步阻塞的过
程，它必须要等到他们所在的那个方法执行完毕后，接着去finish或者start一个Activity，并且startActivity先于
finish解除阻塞。

四、回调方法应该干些甚么

回调方法的作用，就是通知我们Activity生命周期的改变，然后我们可以处理这种改变，以便程序不会崩溃或者数据丢失等等，也就是拥有更好的用户体检，那么这么多回调方法里到底应该怎么做呢？

这个问题不好总结，因为不同的应用、不同的Activity所干的事都不一样，有时候我们甚至只需要实现一个onCreate就行了。所以下面所说的，看看即可，不一定符合所有的情况。

1、onCreate

最重要是在里面调用setContentView，还可以在里面初始化各控件、设置监听、并初始化一些全局的变量。

因为在Activity的一次生命周期中，onCreate方法只会执行一次。在Paused和Stopped状态下恢复或重启的下，这些控件、监
听和全局变量也不会丢失。即便是内存不足，被回收了，再次Recreate的话，又是一次新的生命周期的开始，又会执行onCreate方法。

当Activity被第首次加载时执行。我们新启动一个程序的时候其主窗体的 onCreate事件就会被执行。如果Activity被销毁后（onDestroy后），再重新加载进Task时，其onCreate事件也会被重新执 行。注意这里的参数 savedInstanceState（Bundle类型是一个键值对集合，大家可以看成是.Net中的Dictionary）是一个很有用的设计，由于 前面已经说到的手机应用的特殊性，一个Activity很可能被强制交换到后台（交换到后台就是指该窗体不再对用户可见，但实际上又还是存在于某个 Task中的，比如一个新的Activity压入了当前的Task从而“遮盖”住了当前的 Activity，或者用户按了Home键回到桌面，又或者其他重要事件发生导致新的Activity出现在当前Activity之上，比如来电界面）， 而如果此后用户在一段时间内没有重新查看该窗体（Android通过长按Home键可以选择最近运行的6个程序，或者用户直接再次点击程序的运行图标，如 果窗体所在的Task和进程没有被系统销毁，则不用重新加载，直接重新显示Task顶部的Activity，这就称之为重新查看某个程序的窗体），该窗体 连同其所在的 Task和Process则可能已经被系统自动销毁了，此时如果再次查看该窗体，则要重新执行 onCreate事件初始化窗体。而这个时候我们可能希望用户继续上次打开该窗体时的操作状态进行操作，而不是一切从头开始。例如用户在编辑短信时突然来 电，接完电话后用户又去做了一些其他的事情，比如保存来电号码到联系人，而没有立即回到短信编辑界面，导致了短信编辑界面被销毁，当用户重新进入短信程序 时他可能希望继续上次的编辑。这种情况我们就可以覆写Activity的 void onSaveInstanceState(Bundle outState)事件，通过向outState中写入一些我们需要在窗体销毁前保存的状态或信息，这样在窗体重新执行onCreate的时候，则会通过 savedInstanceState将之前保存的信息传递进来，此时我们就可以有选择的利用这些信息来初始化窗体，而不是一切从头开始。

还可以在onCreate执行数据操作，比如从Cursor中检索数据等等，但是如果你每次进入这个Activity都可能需要更新数据，那么最好放在onStart里面。（这个需要根据实际情况来确定）

2、onDestory

确定某些资源是否没有被释放，做一些最终的清理工作，比如在这个Activity的onCreate中开启的某个线程，那么就要在onDestory中确定它是否结束了，如果没有，就结束它。

3、onStart和onRestart、onStop

Activity进入到Stopped状态之后，它极有可能被系统所回收，在某些极端情况下，系统可能是直接杀死应用程序的进程，而不是调用onDestory方法，所以我们需要在onStop方法中尽可能的释放那些用户暂时不需要使用的资源，防止内存泄露。

尽管onPause在onStop之前执行，但是onPause只适合做一些轻量级的操作，更多的耗时耗资源的操作还是要放在onStop里面，比如说对数据保存，需要用到的数据库操作。

因为从Stopped状态重启之后， onStart和onRestart方法都会被执行，所以我们要判断哪些操作分别要放在哪个方法里面
。因为可能在onStop方法里面释放了一些资源，那么我们必须要重启他们，这个时候这些重启的操作放在onStart方法里面就比较好（因为
onCreate之后也需要开启这些资源）。那些因为Stopped之后引发的需要单独操作的代码，就可以放在onRestart里面。

4、onResume和onPause

onPause和onResume中做的操作，其实意义上和onStart和inStop差不多，只不过是要更轻量级的，因为onPause不能阻塞转变到下一个Activity。

比如：停止动画、取消broadcast receivers。当然相应的需要在onResume中重启或初始化等等。

有时候也需要在onPause判断用户是调用finish结束这个Activity，还是暂时离开，以便区分处理。这时候可以调用
isFinishing()方法来判断。如果是用户finish这个Activity，那么返回为true，如果只是暂时离开或者被系统回收的话，就返回
false。

5. onRestart()   重新启动activity时调用。该活动仍在栈中，而不是启动新的活动。
onStop事件执行后，如果窗体和其所在的进程没有被系统销毁，此时用户又重新查看该窗体，则会执行窗体的onRestart事件，onRestart事件后会跳过窗体的onCreate事件直接执行onStart事件。