activity启动模式（Android中的Activity详解--启动模式与任务栈）
- Android中的Activity详解--启动模式与任务栈
- Activity四种启动模式有哪些
- Android Activity启动模式与状态保存及恢复详解
- Activity的启动模式有哪几种，分别用于什么
- Android —— Activity的四种启动模式
- Android： Activity启动模式 FLAG_ACTIVITY_NEW_TASK 详细探索
- Activity的启动流程
- activity的启动模式有哪些
- Activity的几种启动模式
目录
activity的简单介绍就不写了，作为最常用的四大组件之一，肯定都很熟悉其基本用法了。
首先，是都很熟悉的一张图，即官方介绍的Activity生命周期图.
情景：打开某个应用的的FirstActivity调用方法如下：
由于之前已经很熟悉了，这里就简单贴一些图。
按下返回键：
重新打开并按下home键：
再重新打开：
在其中打开一个DialogActivity(SecondActivity)
按下返回：
修改SecondAcitvity为普通Activity,依旧是上述操作:
这里强调一下 onSaveInstanceState(Bundle outState) 方法的调用时机：
当Activity有可能被系统杀掉时调用，注意，一定是被系统杀掉，自己调用finish是不行的。
测试如下：FirstActivity启动SecondActivity：
一个App会包含很多个Activity，多个Activity之间通过intent进行跳转，那么原始的Activity就是使用栈这个数据结构来保存的。
Task
A task is a collection of activities that users interact with when performing a certain job. The activities are arranged in a stack (the back stack ), in the order in which each activity is opened.
即若干个Activity的集合的栈表示一个Task。
当App启动时如果不存在当前App的任务栈就会自动创建一个，默认情况下一个App中的所有Activity都是放在一个Task中的，但是如果指定了特殊的启动模式，那么就会出现同一个App的Activity出现在不同的任务栈中的情况，即会有任务栈中包含来自于不同App的Activity。
标准模式，在不指定启动模式的情况下都是以此种方式启动的。每次启动都会创建一个新的Activity实例，覆盖在原有的Activity上，原有的Activity入栈。
测试如下：在FirstActivity中启动FirstActivity:
当只有一个FirstActivity时堆栈情况：
此种模式下，Activity在启动时会进行判断，如果当前的App的栈顶的Activity即正在活动的Activity就是将要启动的Activity，那么就不会创建新的实例，直接使用栈顶的实例。
测试，设置FirstActivity为此启动模式，多次点击FirstActivity中的启动FirstActivity的按钮查看堆栈情况：
（其实点击按钮没有启动新Activity的动画就可以看出并没有启动新Activity）
大意就是：
对于使用singleTop启动或Intent.FLAG_ACTIVITY_SINGLE_TOP启动的Activity，当该Activity被重复启动（注意一定是re-launched，第一次启动时不会调用）时就会调用此方法。
且调用此方法之前会先暂停Activity也就是先调用onPause方法。
而且，即使是在新的调用产生后此方法被调用，但是通过getIntent方法获取到的依旧是以前的Intent，可以通过setIntent方法设置新的Intent。
方法参数就是新传递的Intent.
1.如果是同一个App中启动某个设置了此模式的Activity的话，如果栈中已经存在该Activity的实例，那么就会将该Activity上面的Activity清空，并将此实例放在栈顶。
测试：SecondActivity启动模式设为singleTask，启动三个Activity：
这个模式就很好记，以此模式启动的Activity会存放在一个单独的任务栈中，且只会有一个实例。
测试：SecondActivity启动模式设为singleInstance
结果：
显然，启动了两次ThirdActivity任务栈中就有两个实例，而SecondActivity在另外一个任务栈中，且只有一个。
在使用Intent启动一个Activity时可以设置启动该Activity的启动模式：
这个属性有很多，大致列出几个：
每个启动的Activity都在一个新的任务栈中
singleTop
singleTask
用此种方式启动的Activity，在它启动了其他Activity后，会自动finish.
官方文档介绍如下：
这样看来的话，通俗易懂的讲，就是给每一个任务栈起个名，给每个Activity也起个名，在Activity以singleTask模式启动时，就检查有没有跟此Activity的名相同的任务栈，有的话就将其加入其中。没有的话就按照这个Activity的名创建一个任务栈。
测试：在App1中设置SecondActivity的taskAffinity为“gsq.test”，App2中的ActivityX的taskAffinity也设为“gsq.test”
任务栈信息如下：
结果很显然了。
测试：在上述基础上，在ActivityX中进行跳转到ActivityY,ActivityY不指定启动模式和taskAffinity。结果如下：
这样就没问题了，ActivityY在一个新的任务栈中，名称为包名。
这时从ActivityY跳转到SecondActivity，那应该是gsq.test任务栈只有SecondActivity，ActivityX已经没有了。因为其启动模式是singleTask，在启动它时发现已经有一个实例存在，就把它所在的任务栈上面的Activity都清空了并将其置于栈顶。
还有一点需要提一下，在上面，FirstActivity是App1的lunch Activity，但是由于SecondActivity并没有指定MAIN和LAUNCHER过滤器，故在FirstActivity跳转到SecondActivity时，按下home键，再点开App1，回到的是FirstActivity。
大致就先写这么多吧，好像有点长，废话有点多，估计也有错别字，不要太在意~~~
Activity的启动模式可以通过AndroidManifest.xml文件中的《activity》元素的属性来指定，一共有4中模式：
《activity android:name=“ActivityMain“ android:launchMode=“singleTask“》《/activity》
1 standard
2 singleTop
3 singleTask
4 singleInstance
这4中模式又分两类，standard和signleTop属于一类， singleTask和signleInstance属于另一类。
standard和singleTop属性的 Activity 的实例可以属于任何任务（Task），并且可以位于Activity堆栈的任何位置。比较典型的一种情况是，一个任务的代码执行 startActivity()，如果传递的 Intent 对象没有包含 FLAG_ACTIVITY_NEW_TASK 属性， 指定的 Activity 将被该任务调用，从而装入该任务的Activity 堆栈中。 standard和singleTop的区别在于：standard模式的Activity在被调用时会创建一个新的实例，所有实例处理同一个 Intent对象； 但对于singleTop模式的Activity，如果被调用的任务已经有一个这样的Activity 在堆栈的顶端，那么不会有新的实例创建， 任务会使用当前顶端的Activity实例来处理Intent对象，换句话说，如果被调用的任务包含一个不在堆栈顶端的 singleTop Activity， 或者堆栈顶端为 singleTop 的Activity的任务不是当前被调用的任务，那么，仍然会有一个新的Activity对象被创建。
singleTask 和 singleInstance模式的Activity 仅可用于启动任务的情况， 这种模式的Activity总是处在Activity堆栈的最底端，并且一个任务中只能被实例化一次。两 者的区别在于：对于 singleInstance模式的Activity， 任务的Activity堆栈中如果有这样的Activity，那它将是堆栈中的唯一的 Activity， 当前任务收到的 Intent 都由它处理， 由它开启的其他 Activity 将在其他任务中被启动； 对于 SingleTask模式的Activity，它在堆栈底端，其上方可以有其他Activity被创建， 但是，如果发给该Activity的Intent对象到来时该Activity不在堆栈顶端，那么该Intent对象将被丢弃，但是界面还是会切换到当前 的Activity。
在多Activity开发中，有可能是自己应用间的activity 跳转，或者夹带其他应用的可复用activity。可能会希望跳转到原来某个activity实例，而非产生多个重复的activity。我们可借助 activity 四种启动模式来实现不同的需求：
standard 默认模式 --------- 来了intent，每次都创建新的实例。
singleTop -------- 来了intent, 每次都创建新的实例，仅一个例外：当栈顶的activity 恰恰就是该
activity的实例（即需要创建的实例)时，不再创建新实例。这解决了栈顶复用问题，想一想，你按两次back键，退出的都是同一个activity，这感觉肯定不爽。
singleTask ---------- 来了intent后，检查栈中是否存在该activity的实例，如果存在就把intent发送给它，否则就创建一个新的该activity的实例，放入 一个新的task栈的栈底。肯定位于一个task的栈底，而且栈中只能有它一个该activity实例，但允许其他activity加入该栈。解决了在一 个task中共享一个activity。
singleInstance ----------- 肯定位于一个task的栈底, 并且是该栈唯一的activity。解决了多个task共享一个activity。
???????Activity是 Android组件 中最基本也是最为常见用的四大组件（Activity，Service服务，Content Provider内容提供者，BroadcastReceiver广播接收器）之一 。
???????Activity是一个应用程序 组件 ，提供一个 屏幕 ，用户可以用来交互为了完成某项任务。
???????Activity中所有操作都与用户密切相关，是一个负责与 用户交互 的组件，可以通过setContentView(View)来 显示指定控件 。
???????在一个android应用中，一个Activity通常就是一个单独的屏幕，它上面可以显示一些控件也可以监听并处理用户的事件做出响应。Activity之间通过Intent进行通信。
???????关于Activity启动流程请参考之前的文章 Android activity启动流程分析
???????activity有四种启动模式，分别为standard，singleTop，singleTask，singleInstance。如果要使用这四种启动模式，必须在manifest文件中《activity》标签中的launchMode属性中配置。
???????标准的默认启动模式，这种模式下activity可以被多次实例化，即在一个task中可以存在多个activity，每一个activity会处理一个intent对象，（在A中再次启动A，会存在后面的A在前面的A上面，当前task会存在两个activity的实例对象）
???????如果一个singleTop模式启动的activity实例已经存在于栈顶，那么再次启动这个activity的时候，不会重新创建实例，而是重用位于栈顶的那个实例，并且会调用实例的onNewIntent()方法将Intent对象传递到这个实例中，如果实例不位于栈顶，会创建新的实例。
???????启动模式设置为singleTask，framework在启动该activity时只会把它标示为可在一个新任务中启动，至于是否在一个新任务中启动，还要受其他条件的限制，即taskAffinity属性。
??????? taskAffinity ：默认情况下，一个应用中的所有activity具有相同的taskAffinity，即应用程序的包名。我们可以通过设置不同的taskAffinity属性给应用中的activity分组，也可以把不同的应用中的activity的taskAffinity设置成相同的值，当两个不同应用中的activity设置成相同的taskAffinity时，则两个activity会属于同一个TaskRecord。
???????在启动一个singleTask的Activity实例时，如果系统中已经存在这样一个实例，就会将这个实例调度到任务栈的栈顶，并清除它当前所在任务中位于它上面的所有的activity；如果这个已存在的任务中不存在一个要启动的Activity的实例，则在这个任务的顶端启动一个实例；若这个任务不存在，则会启动一个新的任务，在这个新的任务中启动这个singleTask模式的Activity的一个实例。
???????以singleInstance模式启动的Activity具有全局唯一性，即整个系统中只会存在一个这样的实例，如果在启动这样的Activiyt时，已经存在了一个实例，那么会把它所在的任务调度到前台，重用这个实例。
???????以singleInstance模式启动的Activity具有独占性，即它会独自占用一个任务，被他开启的任何activity都会运行在其他任务中（官方文档上的描述为，singleInstance模式的Activity不允许其他Activity和它共存在一个任务中）。
???????被singleInstance模式的Activity开启的其他activity，能够开启一个新任务，但不一定开启新的任务，也可能在已有的一个任务中开启，受条件的限制，这个条件是：当前系统中是不是已经有了一个activity B的taskAffinity属性指定的任务。
???????涉及到Activity启动，就不得不说一下Activity的管理，Activity是以什么方式及被什么类来进行管理的，涉及的类主要如下：
???????历史栈中的一个条目，代表一个activity。ActivityRecord中的成员变量task表示其所在的TaskRecord，ActivityRecord与TaskRecord建立了联系。
???????内部维护一个 ArrayList《ActivityRecord》 用来保存ActivityRecord，TaskRecord中的mStack表示其所在的ActivityStack，TaskRecord与ActivityStack建立了联系。
???????内部维护了一个 ArrayList《TaskRecord》 ，用来管理TaskRecord，ActivityStack中持有ActivityStackSupervisor对象，由ActivityStackSupervisor创建。
???????负责所有ActivityStack的管理。内部管理了mHomeStack、mFocusedStack和mLastFocusedStack三个Activity栈。其中，mHomeStack管理的是Launcher相关的Activity栈；mFocusedStack管理的是当前显示在前台Activity的Activity栈；mLastFocusedStack管理的是上一次显示在前台Activity的Activity栈。
???????ActivityThread 运行在UI线程（主线程），App的真正入口。
???????用来实现AMS和ActivityThread之间的交互。
???????负责调用Activity和Application生命周期。
???????当一个Activity未被主动关闭，即“被动关闭”时，可能需要系统给用户提供保持一些状态的入口。
???????前面说的入口就是：Activity提供了onSaveInstanceState()方法，该方法是Activity在关闭前保存状态的核心方法。
???????前面提到“被动关闭”，如果是主动关闭那么就不会调用，比如：按back键、调用finish()等，那么“被动关闭“的场景有哪些呢？下面给列举一下：
???????肯定在调用onStop()前被调用，但不保证在onPause()前 / 后，一般是在onPause()后调用。
???????当需要保持状态时，在onSaveInstanceState()内执行以下逻辑：
???????当需要恢复时，在onCreate()内部执行以下逻辑：
???????布局每个View默认实现：onSaveInstanceState()，即UI的任何改变都会自动的存储和在activity重新创建的时候自动的恢复(只有在为该UI提供了唯一ID后才起作用)；
???????若需复写该方法从而存储额外的状态信息时，应先调用父类的onSaveInstanceState()（因为默认的onSaveInstanceState()帮助UI存储它的状态）；
???????只使用该方法记录Activity的瞬间状态（UI的状态），而不是去存储持久化数据，因为onSaveInstanceState()调用时机不确定性；可使用 onPause()存储持久化数据；
???????Activity提供了onRestoreInstanceState()方法，该方法是Activity在重新创建后恢复之前保存状态的核心方法。
???????若被动关闭了Activity，即调用了onSaveInstanceState()，那么下次启动时会调用onRestoreInstanceState()。
???????onCreate()---》onStart()---》onRestoreInstanceState()---》onResume()
??????? 注意： onSaveInstanceState（）、onRestoreInstanceState（）不一定 成对被调用
???????如：当正在显示Activity A时，用户按下HOME键回到主界面，然后用户紧接着又返回到Activity A，此时Activity A一般不会因为内存的原因被系统销毁，故Activity A的onRestoreInstanceState()不会被执行；
???????针对以上情况，onSaveInstanceState保持的参数可以选择在onCreate()内部进行解析使用，因为onSaveInstanceState的bundle参数会传递到onCreate方法中，可选择在onCreate()中做数据还原。
??????? 至此：Activity的启动模式及Activity的状态保持及恢复介绍完毕。
刚好最近又梳理了一下，结合我的实际使用场景回答一下= =
有四种启动模式，需要知道的是activity是交由activity栈（任务栈）管理的
standard?:?会在启动时创建一个新实例入栈，所以每次打开都是一个新的界面
场景：默认模式，一般的activity用这个就好
singleTop：当启动activity时，有相同的activity在前台与用户交互，就复用这个activity，回调onNewIntent()方法，避免栈顶的activity被重复的创建；如果没在栈顶，依然会创建新的实例加在栈顶
场景：这个主要针对重复打开的情况，比如你点击通知栏，跳转到消息中心，如果此时消息中心已经打开，就不会重新打开新的界面，合乎逻辑
singleTask：类似singleTop，也是避免重复创建，唯一不同的是，当启动activity时，有相同的activity在栈内，会复用此activity，回调onIntent()，并清空此activity之上所有activity
场景：一般用于程序主界面，利用清空activity的特性，比如你在应用内，打开了多个界面，触发了某个操作后都需要跳转到首页，设置了singleTask之后，就直接启动主页就好，会把之前打开的全部关掉（免得你手动一个一个关闭activity）
singleInstance：顾名思义，单一实例，整个手机操作系统里面只有一个实例存在。不同的应用去打开这个activity 共享公用的同一个activity
场景：常见于系统呼叫来电界面，每个应用打开不会重新创建新的该拨打界面。这种模式比较少用，除非你确定需要使该Activity只有一个实例
最后，上面介绍是在默认没有指定taskAffinity的情况下（即包名），具体想要更深入或者实现更复杂的场景，请结合taskAffinty和Intent Flag具体分析，在此就不介绍了。
以上。
除了Activity的生命周期外，Activity的启动模式也是一个难点，有时候为了满足项目的特殊需求，就必须使用Activity的启动模式。
在默认情况下，当我们多次启动同一个Activity的时候，系统会创建多个实例并把它们放入任务栈中，但是有些场景重复创建多个实例，是没有必要且浪费资源的，这就需要启动模式来修改系统的默认行为。
下面，我将以理论+实践的形式为大家介绍Activity的启动模式。
这是系统的默认启动模式，采用这种模式的Activity无论是否已经存在实例，都会重新创建一个实例，在这种模式下谁启动了这个Activity，那么这个Activity就运行在启动它的那个Activity所在的栈中。
实践：MainActivity 采用 standard 模式
在这种模式下，如果新的Activity已经位于任务栈的栈顶，那么此Activity不会被重新创建，同时它的 NewIntent 方法将会被回调。如果新Activity的实例已存在但不是位于栈顶，那么新Activity依然会被创建。
实践：MainActivity 采用 singleTop 模式
MainActivity 采用 singleTop 模式，SecondActivity采用 standard 模式
这是一种单实例模式，在这种模式下，只要Activity在一个栈中存在，那么多次启动此Activity都不会重新创建实例，而是回调 onNewIntent() 。
实践：MainActivity 采用 singleTask 模式
MainActivity 采用 singleTask 模式，SecondActivity采用 standard 模式
这是一种加强的 singleTask 模式，它除了具有 singleTask 模式的所有特性外，还加强了一点，那就是具有此模式的Activity只能单独的位于一个任务栈中。
实践：MainActivity 采用 singleInstance 模式
MainActivity 采用 singleInstance 模式，SecondActivity采用 standard 模式
以上就是Activity启动模式的介绍。
欢迎留言指出错误。
最近遇到了一个小问题，在我使用了多种Activity启动模式的时候，重新打开其中的一个Activity会启动另一个我已经停止的Activity，从而调用了一些已经失效的方法导致程序崩溃。
由于项目工程复杂，Activity名称不够直观，我新建了一个ActivityTaskTest 工程来重现遇到的问题。
ActivityA是工程的主活动。因为一些必要的原因， ActivityA的启动模式是SingleInstance的。ActivityA可以启动ActivityB，ActivityB没有设置任何启动模式，即默认的standard启动模式。在ActivityB中，将会启动一个ServiceA。 ServiceA中启动一个了一个ActivityC，由于Activity是在非Acitivity环境下启动的，需要设置 FLAG_ACTIVITY_NEW_TASK标签（这里就是我们讨论的重点，稍候会详细分析）。当ActivityC完成任务后会重新跳转到ActivityA。
最后，见证奇葩的时刻到了，我们点击ActivityA的启动ActivityB的button，ActivityC出现在了我们的眼前，而不是ActivityB！！这一刻我仿佛刘谦附体，但在我发现我身边并没有董卿之后，我深刻地意识到了我是一个工程师，不能搞这些装神弄鬼的事情。ok，Let’s find out what‘s going on with our precious app！
关于Activity启动模式和Activity Task的内容推荐一篇非常好的文章： Android中Activity四种启动模式和taskAffinity属性详解 。这篇文章已经讲得非常详细了，这里就不再赘述了，偷个懒哈哈。
如果你已经看了文章，你应该已经知道问题的所在了，对，就是这个该死的taskAffinity。简单的说，就是我们虽然使用了FLAG_ACTIVITY_NEW_TASK标签去启动了ActivityC，但是因为我们忘了给Activity设置taskAffinity这个小婊砸，所以导致ActivityC的taskAffinity值和ActivityB一样都是默认的包名。所以我们启动ActivityC的时候系统将ActivityC压入了ActivityB所在的task。我们可以使用adb shell dumpsys activity activities 指令看下一在我们重新从A中启动B之前，Task的情况：
我们可以看到正如我们所想的，ActivityC和ActivityB在一个Task中，由于ActivityA是singleInstance模式，所以A只能做一辈子单身狗了。那么为什么我们明明启动的是B，怎么会出现C呢？
我们来先看看Google官方文档对于FLAG_ACTIVITY_NEW_TASK是怎么说的：
注意文档中的内容，“如果要启动的 activity 已经运行于某 task 中，则那个 task 将调入前台，最后保存的状态也将恢复”，注意这里是所在task被直接调入前台，也就是说B所在的整个Task将被移入前台。这就解释了为什么我们去启动B而出现的是C了。看起来我们好像大功告成了，但是，等等，总觉得哪里有点不太对劲，我们的ActivityB明明没有设置启动模式啊，你这个是FLAG_ACTIVITY_NEW_TASK标签，我没用啊，我读书多你可别骗我。
仔细想想应该是ActivityA的singleInstance的锅。
我们再来看看Google官方文档对于singleInstance是怎么说的吧：
看到最后一句，终于可以结案了。也就是说，当一个被设置为singleInstance的Activity去启动其他的Activity的时候，其默认是自带FLAG_ACTIVITY_NEW_TASK标签的。
1、FLAG_ACTIVITY_NEW_TASK标签必须配合taskAffinity属性使用，如果不设置taskAffinity属性值，将不会生成新task。
2、当从启动模式为singleInstance的Acitivity中启动新的Acitivity时，新的Activity自带FLAG_ACTIVITY_NEW_TASK标签。
心得：官方文档是个好东西。
开发中我们会调用startActivity来启动一个Activity，最终会调到 startActivityForResult ：
Instrumentation 是Android系统里面的一套控制方法或者“钩子”。这些钩子可以在正常的生命周期（正常是由操作系统控制的）之外控制Android控件的运行。
Application和Activity的所有生命周期中，都会先调用Instrumentation提供的相应方法（如callActivityOnCreate，callApplicationOnCreate，newActivity，callActivityOnNewIntent）
Instrumentation.execStartActivity
ActivityTaskManager.getService()返回了一个IActivityTaskManager，拿到的是ATMS的代理对象，跨进程调用了ATMS的startActivity方法。
ActivityStarter.startActivityMayWait
ActivityStarter中做了一系列的调用（收集Intent信息，处理startActivityForResult，做一些校验判断等），最终进入startActivityUnchecked。
startActivityUnchecked
startActivityUnchecked中处理了关于Activity启动模式的处理，接着真正的resume我们的Activity
这里会先判断应用进程是否创建，创建了就进入 realStartActivityLocked ，没创建就会调用 ActivityManagerInternal.startProcess
①热启动realStartActivityLocked
接着看ActivityThread中接收并处理消息的handleMessage
前面realStartActivityLocked方法中通过addCallback，传入参数LaunchActivityItem。executeCallbacks方法中取出callbacks集合中的LaunchActivityItem，并调用其execute方法
handleLaunchActivity
②冷启动创建应用进程ActivityManagerInternal.startProcess
ActivityManagerInternal的实现类是AMS中的LocalService，AMS通过Socket与Zygote通信，fork出App进程，app进程创建后，会执行ActivityThread的main方法（Android进程入口方法）
调用ActivityThread的attach
thread.bindApplication 这是一个binder通信的过程
ActivityThread内部的Handler接收到BIND_APPLICATION消息
回到上面attachApplicationLocked的mAtmInternal.attachApplication，调用ATMS的attachApplication
看到了似曾相识的realStartActivityLocked，后面流程和之前一样。Activity启动流程分析完毕。
总结
1）与Activity管理有关的类：
ActivityRecord ：历史栈中的一个条目，代表一个Activity
TaskRecord ：内部维护了一个ArrayList《ActivityRecord》 ，来保存ActivityRecord
ActivityStack ：内部维护了一个ArrayList《TaskRecord》，用来管理TaskRecord
ActivityStackSupervisor ：用来管理ActivityStack的
2）Activity启动流程
Activity的四种启动模式：standard：这是默认模式，每次激活Activity时都会创建Activity实例，并放入任务栈中。
singleTop： 如果在任务的栈顶正好存在该Activity的实例，就重用该实例( 会调用实例的 onNewIntent() )，否则就会创建新的实例并放入栈顶，即使栈中已经存在该Activity的实例，只要不在栈顶，都会创建新的实例。
singleTask：如果在栈中已经有该Activity的实例，就重用该实例(会调用实例的 onNewIntent() )。重用时，会让该实例回到栈顶，因此在它上面的实例将会被移出栈。如果栈中不存在该实例，将会创建新的实例放入栈中。
singleInstance：在一个新栈中创建该Activity的实例，并让多个应用共享该栈中的该Activity实例。一旦该模式的Activity实例已经存在于某个栈中，任何应用再激活该Activity时都会重用该栈中的实例( 会调用实例的 onNewIntent() )。其效果相当于多个应用共享一个应用，不管谁激活该 Activity 都会进入同一个应用中。
位置在 AndroidManifest.xml 文件中 Activity 元素的 android:launchMode 属性。
一.先理解栈的概念(放置Activity实例的容器)
1.Task(线性表)
任务栈Task，用来放置Activity实例的容器，先进后出，主要有2个基本操作：压栈和出栈，其所存放的Activity是不支持重新排序的， 只能根据压栈和出栈操作更改Activity的顺序 。
2.app启动时，系统会为它默认创建一个对应的Task，用来放置根Activity
ps: Activity之间可以相互启动，当前应用的Activity可以去启动其他应用的Activity(相机),那么就是说栈的功能可以把其它app的activity加入到自己app的栈里.
所以Task可以理解为负责管理所有用到的Activity实例的栈,但是.android5.0之后 跨进程调用activity,这个activity会被放入到一个新的栈中。
二.启动模式(只能根据压栈和出栈操作更改Activity的顺序,所以是启动模式是以哪种姿势入栈)
通过在AndroidManifest文件中的属性andorid:launchMode来设置或者通过Intent的flag来设置
1.standard（常规姿势入栈）
默认模式。在这个模式下，都会默认创建一个新的实例。因此，在这种模式下，可以有多个相同的实例，也允许多个相同Activity叠加。应用场景：绝大多数Activity。
2.singleTop（栈顶复用姿势入栈）==FLAG_ACTIVITY_SINGLE_TOP
栈顶复用模式，如果要开启的activity在任务栈的顶部已经存在，就不会创建新的实例，而是调用 onNewIntent() 方法。避免栈顶的activity被重复的创建。应用场景：在通知栏点击收到的通知，然后需要启动一个Activity，这个Activity就可以用singleTop，否则每次点击都会新建一个Activity。某个场景下连续快速点击，启动了两个Activity。如果这个时候待启动的Activity使用 singleTop模式也是可以避免这个Bug的。
3.singleTask（栈内复用姿势入栈）==FLAG_ACTIVITY_CLEAR_TOP
栈内复用模式， activity只会在任务栈里面存在一个实例。如果要激活的activity，在任务栈里面已经存在，就不会创建新的activity，而是复用这个已经存在的activity，调用 onNewIntent() 方法，并且清空这个activity任务栈上面所有的activity( CLEAR_TOP回到栈顶 )。应用场景：大多数App的主页。对于大部分应用，当我们在主界面点击回退按钮的时候都是退出应用，那么当我们第一次进入主界面之后，主界面位于栈底，以后不管我们打开了多少个Activity，只要我们再次回到主界面，都应该使用将主界面Activity上所有的Activity移除的方式来让主界面Activity处于栈顶，而不是往栈顶新加一个主界面Activity的实例，通过这种方式能够保证退出应用时所有的Activity都能报销毁。
4.singleInstance（不入栈）
单一实例模式，整个手机操作系统里面只有一个实例存在。不同的应用去打开这个activity 共享公用的同一个activity。他会运行在自己单独，独立的任务栈里面，并且任务栈里面只有他一个实例存在。应用场景：呼叫来电界面。这种模式的使用情况比较罕见，在Launcher中可能使用。或者你确定你需要使Activity只有一个实例。建议谨慎使用。
5.FLAG_ACTIVITY_NO_HISTORY
Activity使用这种模式启动Activity，当该Activity启动其他Activity后，该Activity就消失了，不会保留在Activity栈中。
1.getTaskId();获取当前activity所处的栈
2.同一个应用程序中的activity的亲和性一样(taskAffinity)，也就是说 Actviitya intent时setFalg（Intent.FLAG_ACTIVITY_NEW_TASK）到Activityb 但是Actviitya和Activityb 还是一个栈
在不同的应用中跳转才会创建新的Task。
3.在Activity上下文之外启动Activity需要给Intent设置FLAG_ACTIVITY_NEW_TASK标志，不然会报异常。
四 FLAG_ACTIVITY_CLEAR_TASK（必须和FLAG_ACTIVITY_NEW_TASK一起使用）
清空栈内activity，只留下这个activity
