Android—Activity的四种启动模式及区别

活动的启动模式

启动模式一共有四种，分别是 standard、singleTop、singleTask 和singleInstance，可以在AndroidManifest.xml中通过给activity标签指定android:launchMode 属性来选择启动模式。
1、standard模式
standard 是活动默认的启动模式，在不进行显式指定的情况下，所有活动都会自动使用这种启动模式。 Android 是使用返回栈来管理活动的，在 standard 模式（即默认情况）下，每当启动一个新的活动，它就会在返回栈中入栈，并处于栈顶的位置。对于使用standard 模式的活动，系统不会在乎这个活动是否已经在返回栈中存在，每次启动都会创建该活动的一个新的实例。下面写代码来验证一下：

首先在Androidmanifest文件中的activity标签设置FirstActivity的启动模式为standard：

 <activity android:name=".FirstActivity"
            android:launchMode="standard">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            intent-filter>
        activity>

在OnCreate方法中打印当前栈顶活动的ID，另外加入一个Button，并设置其的监控事件为启动FirstActivity：

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);
        Log.d("FirstActivity",this.toString());
        first_btn = (Button) findViewById(R.id.first_btn);
        first_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(FirstActivity.this,FirstActivity.class));
            }
        });

    }

运行项目，连续点击两次Button，打印信息是这样的:



可见三次Activity的ID都不同，所以要退出程序也要按三次back键。

下面给出standard 模式的原理示意图：

---

2、singleTop模式
当活动的启动模式指定为 singleTop，在启动活动时如果发现返回栈的栈顶已经是该活动，则认为可以直接使用它，不会再创建新的活动实例。

代码：
同样，先设置活动的启动模式为singleTop：

<activity android:name=".FirstActivity"
            android:launchMode="singleTop">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            intent-filter>
        activity>

其它先不改变，运行项目，打印信息：

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

不过当 FirstActivity 并未处于栈顶位置时，这时再启动 FirstActivity，还是会创建新的实例的。下面我们来实验一下，修改 FirstActivity 中 onCreate()方法的代码，如下所示：

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);
        Log.d("FirstActivity",this.toString());
        first_btn = (Button) findViewById(R.id.first_btn);
        first_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(FirstActivity.this,SecondActivity.class));
            }
        });

    }

创建SecondActivity，加入Button并设置其点击事件为启动FirstActivity：

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        Log.d("SecondActivity",this.toString());
        second_btn = (Button) findViewById(R.id.second_btn);
        second_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(SecondActivity.this, FirstActivity.class);
                startActivity(intent);
            }
        });
    }

现在重新运行程序，在 FirstActivity 界面点击按钮进入到 SecondActivity，然后在 SecondActivity 界面点击按钮，又会重新进入到 FirstActivity。
打印信息：



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

下面给出singleTop的原理示意图：

---

3、singleTask模式
当活动的启动模式指定为 singleTask，每次启动该活动时系统首先会在返回栈中检查是否存在该活动的实例，如果发现已经存在则直接使用该实例，并把在这个活动之上的所有活动统统出栈，如果没有发现就会创建一个新的活动实例。

代码：

同样是设置FirstActivity的启动模式为singleTask：

<activity android:name=".FirstActivity"
            android:launchMode="singleTask">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            intent-filter>
        activity>

然后在 FirstActivity 中添加 onRestart()方法，并打印日志：

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("FirstActivity", "onRestart");
    }

最后在 SecondActivity 中添加 onDestroy()方法，并打印日志：

@Override
protected void onDestroy() {
super.onDestroy();
Log.d("SecondActivity", "onDestroy");
}

现在重新运行程序，在 FirstActivity 界面点击按钮进入到SecondActivity，然后在SecondActivity 界面点击按钮，又会重新进入到 FirstActivity。
查看 LogCat 中的打印信息：

从打印信息可以看出，在 SecondActivity 中启动 FirstActivity 时，会发
现返回栈中已经存在一个 FirstActivity 的实例，并且是在SecondActivity 的下面，于是SecondActivity 会从返回栈中出栈，而 FirstActivity 重新成为了栈顶活动，因此 FirstActivity的 onRestart()方法和 SecondActivity 的 onDestroy()方法会得到执行。现在返回栈中应该只剩下一个 FirstActivity 的实例了，按一下 Back 键就可以退出程序。
singleTask 模式的原理示意图：

---

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

代码：
同样设置Activity启动模式为singleInstance：

 <activity android:name=".FirstActivity"
            android:launchMode="singleInstance">
            <intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER"/>
            intent-filter>
        activity>

修改 FirstActivity 中onCreate()方法的代码：在 onCreate()方法中打印了当前返回栈的 id

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);
        Log.d("FirstActivity","Task id is " + getTaskId());
        first_btn = (Button) findViewById(R.id.first_btn);
        first_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(FirstActivity.this,SecondActivity.class));
            }
        });

    }

修改 SecondActivity 中 onCreate()方法的代码：同样在 onCreate()方法中打印了当前返回栈的 id，然后又修改了按钮点击事件的代码，用于启动 ThirdActivity。

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        Log.d("SecondActivity","Task id is " + getTaskId());
        second_btn = (Button) findViewById(R.id.second_btn);
        second_btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(SecondActivity.this, ThridActivity.class);
                startActivity(intent);
            }
        });
    }

最后修改 ThirdActivity 中 onCreate()方法的代码：仍然是在 onCreate()方法中打印了当前返回栈的 id。

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_thrid);
        Log.d("ThirdActivity", "Task id is " + getTaskId());
    }

现在重新运行程序，在 FirstActivity界面点击 按钮进入 到 SecondActivity， 然 后 在 SecondActivity 界 面 点击按钮进入 到ThirdActivity。
查看 LogCat 中的打印信息：



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

singleInstance 模式的原理示意图：