Android 基础 —— 活动的启动模式

活动的启动模式来说应该是个全新的概念，在实际项目中我们应该根据特定的需求为每个活动指定恰当的启动模式。启动模式一共有四种，分别是standard、singleTop、singleTask 和singleInstance ， 可以在AndroidManifest.xml 中通过给<activity> 标签指定Android:launchMode属性来选择启动模式。

Standard：标准模式.默认启动模式，在不显式指定的情况下，所有的活动都是使用这种模式，每次都会创建新的活动实例

SingleTop：栈顶复用模式。在启动活动时如果发现返回栈的栈顶已经是该活动，则可以认为直接使用它，不再创建新的活动实例
如果启动的活动处于任务栈中但不处于栈顶，这个时候会重新创建该活动实例

SingleTask：栈内复用模式。每次启动活动的时候都会检查返回栈中该活动是否已经存在，若不存在则创建新的活动实例，若存在则直接使用该活动，并且处于该活动之上的活动实例全部出栈

SingleInstance：单实例模式。若一个活动指定为该启动模式，则会创建一个新的任务栈来管理此活动（好处是方便别的应用程序可以调用我们这个活动），当别的应用程序调用此活动时不必再重新创建该活动实例

 

下面我们来分别学习：

一、 standard(标准启动模式)

         standard 是活动默认的启动模式，在不进行显式指定的情况下，所有活动都会自动使用这种启动模式。因此，到目前为止我们写过的所有活动都是使用的standard 模式。经过上一节的学习，你已经知道了Android 是使用返回栈来管理活动的，在standard 模式（即默认情况）下，每当启动一个新的活动，它就会在返回栈中入栈，并处于栈顶的位置。对于使用standard 模式的活动，系统不会在乎这个活动是否已经在返回栈中存在，每次启动都会创建该活动的一个新的实例。

         我们现在通过实践来体会一下standard 模式，修改FirstActivity 中onCreate()方法的代码，如下所示：

[java] view plain copy

 

1. public class MainActivity extends Activity {  
2.   
3.     @Override  
4.     protected void onCreate(Bundle savedInstanceState) {  
5.         super.onCreate(savedInstanceState);  
6.         setContentView(R.layout.activity_main);  
7.       
8.         Button button1 = (Button)findViewById(R.id.button1);  
9.         Log.d("MainActivity", this.toString());  
10.   
11.         button1.setOnClickListener(new OnClickListener() {  
12.               
13.             @Override  
14.             public void onClick(View v) {  
15.                 // TODO Auto-generated method stub  
16.                 Intent intent = new Intent(MainActivity.this,MainActivity.class);  
17.                 startActivity(intent);  
18.             }  
19.         });  
20.     }  
21. }  

代码看起来有些奇怪吧，在MainActivity 的基础上启动MainActivity。从逻辑上来讲这确实没什么意义，不过我们的重点在于研究standard 模式，因此不必在意这段代码有什么实际用途。另外我们还在onCreate()方法中添加了一行打印信息，用于打印当前活动的实例。

现在重新运行程序，然后在MainActivity 界面连续点击两次按钮，可以看到LogCat 中打印信息

 

      从打印信息中我们就可以看出，每点击一次按钮就会创建出一个新的MainActivity 实例。此时返回栈中也会存在三个MainActivity的实例，因此你需要连按三次Back键才能退出程序。
standard 模式的原理示意图，如图所示

 

 

二、 singleTop(栈顶复用模式)

       可能在有些情况下，你会觉得standard 模式不太合理。活动明明已经在栈顶了，为什么再次启动的时候还要创建一个新的活动实例呢？别着急，这只是系统默认的一种启动模式而已，你完全可以根据自己的需要进行修改，比如说使用singleTop 模式。当活动的启动模式指定为singleTop，在启动活动时如果发现返回栈的栈顶已经是该活动，则认为可以直接使用它，不会再创建新的活动实例。

我们还是通过实践来体会一下，修改AndroidManifest.xml 中MainActivity 的启动模式，如下所示：

[java] view plain copy

 

1. <activity  
2.             android:name="cn.com.qiang.singleTop.MainActivity"  
3.             android:label="@string/app_name"   
4.             android:launchMode="singleTop">  
5.             <intent-filter>  
6.                 <action android:name="android.intent.action.MAIN" />  
7.   
8.                 <category android:name="android.intent.category.LAUNCHER" />  
9.             </intent-filter>  
10. </activity>  

然后重运行程序，查看LogCat 会看到已经创建了一个MainActivity 的实例，如图所示。

但是之后不管你点击多少次按钮都不会再有新的打印信息出现，因为目前MainActivity已经处于返回栈的栈顶，每当想要再启动一个MainActivity 时都会直接使用栈顶的活动，因此MainActivity 也只会有一个实例，仅按一次Back 键就可以退出程序。

不过当MainActivity 并未处于栈顶位置时，这时再启动MainActivity，还是会创建新的实例的。下面我们来实验一下，在MainActivity 中添加第二个按钮onCreate()方法的代码，如下所示：

[java] view plain copy

 

1. Button button2 = (Button)findViewById(R.id.button2);  
2. button2.setOnClickListener(new OnClickListener() {  
3.               
4.     @Override  
5.     public void onClick(View v) {  
6.     // TODO Auto-generated method stub  
7.     Intent intent = new Intent(MainActivity.this,SecondActivity.class);  
8.     startActivity(intent);  
9.     }  
10. });  

按钮功能是跳转到第二个界面，下面修改SecondActivity

[java] view plain copy

 

1. Log.v("MainActivity", this.toString());  
2. Button button3 = (Button)findViewById(R.id.button3);  
3. button3.setOnClickListener(new OnClickListener() {  
4.               
5.     @Override  
6.     public void onClick(View v) {  
7.     // TODO Auto-generated method stub  
8.     Intent intent = new Intent(SecondActivity.this,MainActivity.class);  
9.     startActivity(intent);  
10.     }  
11. });  

我们在SecondActivity 中的按钮点击事件里又加入了启动MainActivity 的代码。现在重新运行程序，在MainActivity 界面点击按钮进入到SecondActivity，然后在SecondActivity 界面点击按钮，又会重新进入到MainActivity。查看LogCat 中的打印信息，如图所示

可以看到系统创建了两个不同的MainActivity 实例，这是由于在SecondActivity 中再次启动MainActivity 时，栈顶活动已经变成了SecondActivity，因此会创建一个新的MainActivity实例。现在按下Back 键会返回到SecondActivity，再次按下Back 键又会回到FirstActivity，再按一次Back 键才会退出程序。

singleTop 模式的原理示意图，如图2.34 所示。

 

 

三、singleTask

        使用singleTop 模式可以很好地解决重复创建栈顶活动的问题，但是正如你在上一节所看到的，如果该活动并没有处于栈顶的位置，还是可能会创建多个活动实例的。那么有没有什么办法可以让某个活动在整个应用程序的上下文中只存在一个实例呢？这就要借助singleTask 模式来实现了。当活动的启动模式指定为singleTask，每次启动该活动时系统首先会在返回栈中检查是否存在该活动的实例，如果发现已经存在则直接使用该实例，并把在这个活动之上的所有活动统统出栈，如果没有发现就会创建一个新的活动实例。

        由于其和singleTop类似，这里不再详细介绍其特点。singleTask 模式的原理示意图：

 

 

四、 singleInstance

         singleInstance 模式应该算是四种启动模式中最特殊也最复杂的一个了，你也需要多花点功夫来理解这个模式。不同于以上三种启动模式，指定为singleInstance 模式的活动会启用一个新的返回栈来管理这个活动（其实如果singleTask 模式指定了不同的taskAffinity，也会启动一个新的返回栈）。那么这样做有什么意义呢？想象以下场景，假设我们的程序中有一个活动是允许其他程序调用的，如果我们想实现其他程序和我们的程序可以共享这个活动的实例，应该如何实现呢？使用前面三种启动模式肯定是做不到的，因为每个应用程序都会有自己的返回栈，同一个活动在不同的返回栈中入栈时必然是创建了新的实例。而使用singleInstance 模式就可以解决这个问题，在这种模式下会有一个单独的返回栈来管理这个活动，不管是哪个应用程序来访问这个活动，都共用的同一个返回栈，也就解决了共享活动实例的问题。

        修改AndroidManifest.xml 中SecondActivity 的启动模式：

[java] view plain copy

 

1. <activity   
2.     android:launchMode="singleInstance"  
3.     android:name="cn.com.qiang.singleInstance.SecondActivity">  
4. </activity>  

修改MainActivity 中onCreate()方法的代码：

[java] view plain copy

 

1. protected void onCreate(Bundle savedInstanceState) {  
2.     super.onCreate(savedInstanceState);  
3.     setContentView(R.layout.activity_main);  
4.       
5.     Log.v("MainActivity","Task id is "+getTaskId());  
6.     Button button1 = (Button)findViewById(R.id.button1);  
7.     button1.setOnClickListener(new OnClickListener() {    
8.         @Override  
9.         public void onClick(View v) {  
10.             // TODO Auto-generated method stub  
11.             Intent intent = new Intent(MainActivity.this,SecondActivity.class);  
12.             startActivity(intent);  
13.             }  
14.     });  

修改SecondActivity 中onCreate()方法的代码：

[java] view plain copy

 

1. protected void onCreate(Bundle savedInstanceState) {  
2.     // TODO Auto-generated method stub  
3.     super.onCreate(savedInstanceState);  
4.     setContentView(R.layout.activity_second);  
5.           
6.     Log.v("MainActivity","Task id is "+getTaskId());  
7.     Button button2 = (Button)findViewById(R.id.button2);  
8.     button2.setOnClickListener(new OnClickListener() {  
9.               
10.         @Override  
11.         public void onClick(View v) {  
12.             // TODO Auto-generated method stub  
13.             Intent intent = new Intent(SecondActivity.this,ThirdActivity.class);  
14.               
15.             startActivity(intent);  
16.         }  
17.     });  
18. }  

修改ThirdActivity 中onCreate()方法的代码:

[java] view plain copy

 

1. protected void onCreate(Bundle savedInstanceState) {  
2.     // TODO Auto-generated method stub  
3.     super.onCreate(savedInstanceState);  
4.     setContentView(R.layout.activity_third);  
5.           
6.     Log.v("MainActivity","Task id is "+getTaskId());  
7. }  

仍然是在onCreate()方法中打印了当前返回栈的id。现在重新运行程序，在MainActivity界面点击按钮进入到SecondActivity ，然后在SecondActivity 界面点击按钮进入到ThirdActivity。查看LogCat 中的打印信息，如图所示

      可以看到， SecondActivity 的Task id 不同于MainActivity 和ThirdActivity ， 这说明SecondActivity 确实是存放在一个单独的返回栈里的，而且这个栈中只有SecondActivity 这一个活动。

     然后我们按下Back 键进行返回，你会发现ThirdActivity 竟然直接返回到了MainActivity，再按下Back 键又会返回到SecondActivity，再按下Back 键才会退出程序，这是为什么呢？其实原理很简单，由于FirstActivity 和ThirdActivity 是存放在同一个返回栈里的，当在ThirdActivity 的界面按下Back 键，ThirdActivity 会从返回栈中出栈，那么MainActivity 就成为了栈顶活动显示在界面上，因此也就出现了ThirdActivity 直接返回到MainActivity 的情况。然后在MainActivity 界面再次按下Back 键，这时当前的返回栈已经空了，于是就显示了另一个返回栈的栈顶活动，即SecondActivity。最后再次按下Back 键，这时所有返回栈都已经空了，也就自然退出了程序。

singleInstance 模式的原理示意图