Activity的生命周期

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

了解Activity的生命周期的根本目的就是为了设计用户体验更加良好的应用。因为Activity就相当于MVC中的View层，是为了更好的向用户展现数据，并与之交互。了解Activity的生命周期和各回调方法的触发时机，我们可以更好的在合适的地方向用户展现数据（因为每个应用每个Activity的作用不同，所以具体每个回调方法的最佳实践不好把握，但是只要遵循最基本的原则即可），保证数据的完整性和程序的良好运行。

下面是官方文档的原话：

 

[java] view plaincopy
 
  1. Managing the lifecycle of your activities by implementing callback methods is crucial to developing a strong and flexible application. The lifecycle of an   
  2. activity is directly affected by its association withother activities, its task and back stack.  
  3. 翻：对于开发一个强大和灵活的应用程序，实现Activity的回调方法来管理Activity的生命周期至关重要。  
  4. 一个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可以经常在前台状态发生转换—比如，当设备休眠或者弹出了个对话框。因为经常会发生转换，所以在这两个方法之间的代码应该是轻量级的，防止导致其他转换变慢使得用户需要等待。

 

一个Activity本质上只有三种状态：

Resumed（运行）、Paused（暂停）、Stopped（停止），因为从Activity被创建之后，它只可能在这三种状态保持长久的停留，其他的回调方法结束后的状态都只能称之为过渡状态。比如进入到onStart方法后，执行完该方法，会立即进入到OnResume方法。（这里所说的状态都是指对应的某个方法返回之后）

 

即使一个Activity进入到Paused或者Stopped方法，它仍然是存在的，被保存在任务返回堆栈中。它仍然保持着自身的所有实例和状态，所以根本不用担心它在返回到onResume方法时，实例会变为null，或者控件的事件监听不了（我以前就担心过这个问题）。唯一需要考虑的就是，系统在内存不足的情况下，杀死在Paused或者Stopped状态下的Activity。

当一个Activity在Resumed状态下，它是不会因内存不够而被系统直接杀死（在极端的情况下也有可能被杀死，但是一般不会考虑这种情况）。只有进入Paused或者Stopped状态才会，而且可能根本就不会去调用onStop()和onDestory()方法，所以onPause()方法是我们最大程度上保证Activity在销毁之前能够执行到的方法。因此，如果你的某个Activity需要保存某些数据到数据库，您应该在onPause()里编写持久化数据的代码。但要注意，你应该选择哪些信息必须保留在onPause()，因为这个方法任何阻塞程序都会阻止过渡到下一个Activity，这样给用户体验就感觉十分缓慢。

更多关于Activity被杀死的问题，可以参考 Processes andThreading 

 

 

三、生命周期的验证

1、单个Activity生命周期的变化

写一个简单的Activity，重写所有生命周期的方法，如下：

 

[java] view plaincopy
 
  1. public class LifecycleActivity extends Activity {  
  2.   
  3.     private Button mBtn1;  
  4.   
  5.     @Override  
  6.     public void onCreate(Bundle savedInstanceState) {  
  7.         super.onCreate(savedInstanceState);  
  8.         System.out.println("LifecycleActivity onCreate");  
  9.         setContentView(R.layout.life_cycle_activity);  
  10.         mBtn1 = (Button) findViewById(R.id.btn1);  
  11.         mBtn1.setOnClickListener(new View.OnClickListener() {  
  12.             public void onClick(View v) {  
  13.                 finish();  
  14.             }  
  15.         });  
  16.   
  17.     }  
  18.   
  19.       
  20.     @Override  
  21.     protected void onStart() {  
  22.         super.onStart();  
  23.         System.out.println("LifecycleActivity onStart");  
  24.   
  25.     }  
  26.   
  27.     @Override  
  28.     protected void onResume() {  
  29.         super.onResume();  
  30.         System.out.println("LifecycleActivity onResume");  
  31.     }  
  32.   
  33.     @Override  
  34.     protected void onPause() {  
  35.         super.onPause();  
  36.         System.out.println("LifecycleActivity onPause");  
  37.     }  
  38.   
  39.     @Override  
  40.     protected void onStop() {  
  41.         super.onStop();  
  42.         System.out.println("LifecycleActivity onStop");  
  43.     }  
  44.   
  45.     @Override  
  46.     protected void onDestroy() {  
  47.         super.onDestroy();  
  48.         System.out.println("LifecycleActivity onDestroy");  
  49.     }  
  50.   
  51.       
  52.     @Override  
  53.     protected void onRestart() {  
  54.         super.onRestart();  
  55.         System.out.println("LifecycleActivity onRestart");  
  56.     }  
  57. }  

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

 

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

 

 

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

 

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

 

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

 

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

 

 

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

1、基本的变化

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

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

[java] view plaincopy
 
  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中有一个按钮，点击事件为

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

点击该按钮，打印如下：

[java] view plaincopy
 
  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处于前台，并拥有用户焦点，现在点击返回按钮，打印如下：

[java] view plaincopy
 
  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，打印如下：

[java] view plaincopy
 
  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中有一个按钮，点击事件为

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

点击该按钮，打印如下：

[java] view plaincopy
 
  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处于前台，并拥有用户焦点，现在点击返回按钮，打印如下：

[java] view plaincopy
 
  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中有一个按钮，点击事件为

[java] view plaincopy
 
  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，在里面也增加打印输出。

 

[java] view plaincopy
 
  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. });  

点击改按钮，打印如下：

 

 

[java] view plaincopy
 
  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方法。

 

还可以在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。

 

posted @ 2015-05-23 19:29  刘小神  阅读(301)  评论(0)  编辑  收藏  举报