一个实例让你彻底明白Activity的4种启动模式

首先，我们得有一个概念，就是启动的Activity都是放在相应的任务栈中。按Back键的时候Activity会从任务栈中返回，当任务栈为空时系统就会回收这个任务栈。

那么我们为什么需要这4中启动模式呢？我们新建Activity的并在Androidmanifest.xml文件中注册的时候，默认的就是standard模式，如果你在这个Activity中一直通过startActivity来启动这个Activity，那么任务栈中就会有许多该Activity，你要多次按返回键才能返回到launcher页面。这样的体验简直糟糕啊。

模式1：standard
标准模式，也是Activity默认的启动方式。这个在Androidmanifest.xml中的Activity里声明，如下：

以这种方式启动的Activity每次都会创建一个新的实例，不管这个实例是否已经存在。
比如在 Activity A 中启动 A，那么任务栈中会有2个A。

例子1：ActivityA 中以standard启动 ActivityA，代码如下：

manefest.xml:

ActivityA.java:

public class ActivityA extends Activity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        Log.e("xxx", "ActivityA, onCreate");
        super.onCreate(savedInstanceState);

        TextView tv = new TextView(this);
        tv.setTextSize(20);
        tv.setText("This is activityA");
        tv.setGravity(Gravity.CENTER);
        tv.setBackgroundColor(Color.parseColor("#999999"));

        setContentView(tv, new ViewGroup.LayoutParams(200, 100));

        tv.setFocusable(true);
        tv.requestFocus();


        tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e("xxx","onclick A");
                Intent intent = new Intent(ActivityA.this, ActivityA.class);
                startActivity(intent);
            }
        });

    }

    @Override
    protected void onNewIntent(Intent intent) {
        Log.e("xxx", "ActivityA, onNewIntent");
        super.onNewIntent(intent);
    }
}

log如下：

08-02 19:33:45.720 11791-11791/com.example.aidlclient E/xxx: ActivityA, onCreate
08-02 19:33:59.192 11791-11791/com.example.aidlclient E/xxx: onclick A
08-02 19:33:59.207 11791-11791/com.example.aidlclient E/xxx: ActivityA, onCreate

可以看到 点击跳转到 ActivityA 的时候，任然会执行 onCreate方法。
通过指令：adb shell dumpsys activity activities 查看任务栈：

  Running activities (most recent first):
    TaskRecord{2470eca6 #1587 A=com.example.aidlclient U=0 sz=2}
      Run #1: ActivityRecord{3456102c u0 com.example.aidlclient/luanchmode.ActivityA t1587}
      Run #0: ActivityRecord{352831f7 u0 com.example.aidlclient/luanchmode.ActivityA t1587}

可以看出任务栈中有2个ActivityA 。

模式2：singleTop 栈顶复用模式

在这种模式下启动的Activity，如果该Activity已经位于栈顶，那么就不会去创建新的实例，调用该Activity的onNewIntent方法。如果不在栈顶还是会新建一个Activity实例。

例子： A 启动B，B的启动模式为singleTop ，然后 B 再启动 B；

AndroidManifest.xml如下：

AcitivityA 和 ActivityB 中的部分代码如下：

tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(ActivityA.this, ActivityB.class);
                startActivity(intent);
            }
        });

 tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(ActivityB.this, ActivityB.class);
//                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
                startActivity(intent);
            }
        });

log如下：

08-03 09:13:01.841 26939-26939/com.example.aidlclient E/xxx: ActivityA, onCreate
08-03 09:18:08.513 26939-26939/com.example.aidlclient E/xxx: ActivityB, onCreate
08-03 09:18:09.983 26939-26939/com.example.aidlclient E/xxx: ActivityB, onNewIntent

可以看出从A跳转到B时，由于栈中没有B，所以会新建B的实例并放入栈中；从B跳到B中，由于栈顶以经是B了，所以不会新建实例，而是会调用B的onNewIntent方法。

我们看看任务栈中是不是只有A和B ？

 Running activities (most recent first):
    TaskRecord{351e6f43 #1596 A=com.example.aidlclient U=0 sz=2}
    Run #1: ActivityRecord{2925d326 u0 com.example.aidlclient/luanchmode.ActivityB t1596}
    Run #0: ActivityRecord{1e64c90 u0 com.example.aidlclient/luanchmode.ActivityA t1596}

可以看到任务栈中只有A和B，也可以看出如果如果B在栈顶就不会创建新的实例。接下来我们看看如果B不是栈顶，那又会如何？

接下来的例子是这样的 A 启动 B， B 启动 C, C 再启动 B：
代码很简单就不贴A和B的了，贴下C的。

tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(ActivityC.this, ActivityB.class);
//                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
                startActivity(intent);
            }
        });

log如下：

08-03 09:36:35.259 17108-17108/com.example.aidlclient E/xxx: ActivityA, onCreate
08-03 09:36:39.482 17108-17108/com.example.aidlclient E/xxx: ActivityB, onCreate
08-03 09:36:40.979 17108-17108/com.example.aidlclient E/xxx: ActivityC onCreate
08-03 09:36:42.171 17108-17108/com.example.aidlclient E/xxx: ActivityB, onCreate

可以看出，C再次启动B的时候B会创建新的实例。我们查看下任务栈看看是什么样的，任务栈中应该是 A->B->C->B.

 Running activities (most recent first):
      TaskRecord{1d40b112 #1602 A=com.example.aidlclient U=0 sz=4}
        Run #3: ActivityRecord{3482a81a u0 com.example.aidlclient/luanchmode.ActivityB t1602}
        Run #2: ActivityRecord{a101309 u0 com.example.aidlclient/luanchmode.ActivityC t1602}
        Run #1: ActivityRecord{3575d5f8 u0 com.example.aidlclient/luanchmode.ActivityB t1602}
        Run #0: ActivityRecord{31f704f3 u0 com.example.aidlclient/luanchmode.ActivityA t1602}

以上2个例子验证了，以singleTop启动的Activity，如果栈顶是该Activity，那么不会创建新的实例，如果该Activity不在栈顶，要启动这个Activity还是会创建新的实例。

模式3：singleTask 站内复用模式

在这种模式下，如果Activity存在于栈中，那么启动这个Activity不会创建新的实例，而是会调用onNewIntent()，并且将该Activity上面的所有Activity移出栈；当以singleTask 启动一个Activity的时候，首先去判断是否要为该Activity去创建一个任务栈？怎么判断的我们下面再讲，如果需要的话，那么就会创建一个任务栈，并且将该Activity放入栈中；如果不需要的话，直接将该Activity放入当前的任务栈中。

现在我们来讲怎么判断是否需要创建任务栈？任务栈的创建跟taskAffinity的属性相关，每个Activity都有taskAffinity属性，这个属性指出了它希望进入的Task。如果一个Activity没有显式的指明该Activity的taskAffinity，那么它的这个属性就等于Application指明的taskAffinity，如果Application也没有指明，那么该taskAffinity的值就等于包名。

在singleTask 模式下，如果你在要启动的Activity中设置taskAffinity属性，且该属性的值不等于包名，那么就需要创建任务栈，否则不需要创建。taskAffinity的属性设置如下：

而我的应用的包名是：package=“com.example.aidlclient”>

例子1：A中启动B，B中启动C，然后C启动D，D再启动B，其中A和C、D是standard模式，B是singleTask模式。

manifest.xml如下：

还是先看log：

08-03 10:40:33.896 14823-14823/? E/xxx: ActivityA, onCreate
08-03 10:40:42.777 14823-14823/? E/xxx: ActivityB, onCreate
08-03 10:40:44.169 14823-14823/? E/xxx: ActivityC onCreate
08-03 10:40:45.218 14823-14823/? E/xxx: ActivityD onCreate
08-03 10:40:46.696 14823-14823/? E/xxx: ActivityB, onNewIntent

A->B : 由于栈中没有B且未对B设置android:taskAffinity属性，所以直接创建B的实例并放在该栈中；
B->C->D：创建C和D的实例并放到栈中
D->B : 由于B已经存在栈中，所以直接将B移到栈顶，调用onNewIntent()，并且B上面的Activity全部出栈。

任务栈如下：

Running activities (most recent first):
      TaskRecord{33b61cae #1611 A=com.example.aidlclient U=0 sz=2}
        Run #1: ActivityRecord{2291853f u0 com.example.aidlclient/luanchmode.ActivityB t1611}
        Run #0: ActivityRecord{390ec8d6 u0 com.example.aidlclient/luanchmode.ActivityA t1611}

可以看到A和B都在同一个栈中，且从D跳转到B的时候，B上面的Activity全部出栈。

例子2：为B设置android:taskAffinity="com.example.aidlclient.test"和包名不一样

manifest.xml如下：

log如下：

08-03 10:45:24.335 15566-15566/com.example.aidlclient E/xxx: ActivityA, onCreate
08-03 10:45:38.858 15566-15566/com.example.aidlclient E/xxx: ActivityB, onCreate
08-03 10:45:40.912 15566-15566/com.example.aidlclient E/xxx: ActivityC onCreate
08-03 10:45:42.694 15566-15566/com.example.aidlclient E/xxx: ActivityD onCreate
08-03 10:45:44.406 15566-15566/com.example.aidlclient E/xxx: ActivityB, onNewIntent

A->B：由于B不存在与任务栈中，所以会新建B的实例，至于有没有创建对应的栈，log中看不出，等下通过adb来查看。
B->C->D：正常启动，创建C和D的实例并放入任务栈
D->B：由于B存在于任务栈中，所以直接将B移到栈顶，调用onNewIntent()，并且B上面的Activity全部出栈。

利用 adb shell dumpsys activity查看任务栈情况：

先看 A->B->C->D：的任务栈详情：

 Running activities (most recent first):
      TaskRecord{3874c557 #1618 A=com.example.aidlclient.test U=0 sz=3}
        Run #3: ActivityRecord{84f09e0 u0 com.example.aidlclient/luanchmode.ActivityD t1618}
        Run #2: ActivityRecord{255bda6b u0 com.example.aidlclient/luanchmode.ActivityC t1618}
        Run #1: ActivityRecord{2ac8c0a u0 com.example.aidlclient/luanchmode.ActivityB t1618}
      TaskRecord{1d0e98b2 #1617 A=com.example.aidlclient U=0 sz=1}
        Run #0: ActivityRecord{3863a8b u0 com.example.aidlclient/luanchmode.ActivityA t1617}

可以看出 B、C、D在一个任务栈，A在另外一个任务栈。

先看 A->B->C->D->B：的任务栈详情

   Running activities (most recent first):
      TaskRecord{3874c557 #1618 A=com.example.aidlclient.test U=0 sz=1}
        Run #1: ActivityRecord{2ac8c0a u0 com.example.aidlclient/luanchmode.ActivityB t1618}
      TaskRecord{1d0e98b2 #1617 A=com.example.aidlclient U=0 sz=1}
        Run #0: ActivityRecord{3863a8b u0 com.example.aidlclient/luanchmode.ActivityA t1617}

可以看出，从B->D后，会将B上面的Activity全部移除出栈。

模式4：singleInstance
这种模式下，Activity只能单独的存在一个任务栈中，举个例子，就是说A以singleInstance 启动了B，那么会创建一个任务栈，并把B放到创建的任务栈中，该栈只能有B的存在。

例子1：A启动B，B启动C，其中A、C的启动模式为standard，B的启动模式为singleInstance 。

manifest.xml如下：

log如下：

08-03 11:07:29.810 5490-5490/com.example.aidlclient E/xxx: ActivityA, onCreate
08-03 11:07:37.698 5490-5490/com.example.aidlclient E/xxx: ActivityB, onCreate
08-03 11:07:41.398 5490-5490/com.example.aidlclient E/xxx: ActivityC onCreate
08-03 11:08:37.934 5490-5490/com.example.aidlclient E/xxx: ActivityB, onNewIntent

A->B：由于不存在B需要的任务栈，所以先创建任务栈，然后将B压入栈
B->C：正常启动，创建C的实例并入栈。
C->B：不会创建B新的实例，而是调用onNewIntent()。

先看 A->B->C的任务栈详情：

Running activities (most recent first):
      TaskRecord{2d63becf #1621 A=com.example.aidlclient U=0 sz=2}
        Run #2: ActivityRecord{340fa242 u0 com.example.aidlclient/luanchmode.ActivityC t1621}
      TaskRecord{323683de #1622 A=com.example.aidlclient U=0 sz=1}
        Run #1: ActivityRecord{2aef961d u0 com.example.aidlclient/luanchmode.ActivityB t1622}
      TaskRecord{2d63becf #1621 A=com.example.aidlclient U=0 sz=2}
        Run #0: ActivityRecord{3486b42c u0 com.example.aidlclient/luanchmode.ActivityA t1621}

A->B 会新建一个任务栈然后创建B的实例并压入该栈；B->C 直接创建C的实例并压入之前A所在的栈。

Activity的4种启动模式就写到这里，下面会写Intent中设置flag，以及taskAffinity。