彻底弄懂Activity四大启动模式

最新推荐文章于 2022-07-21 11:17:53 发布
最新推荐文章于 2022-07-21 11:17:53 发布
阅读量505 收藏
点赞数


       最近有几位朋友给我留言，让我谈一下对Activity启动模式的理解。我觉得对某个知识点的理解必须要动手操作才能印象深刻，所以今天写一篇博文，结合案例理解Activity启动模式。由于之前看过“区长”的一篇博文（文章结尾处有链接）深受启发，因此本文是在那篇文章的基础上更加全面的讲解。 
       众所周知当我们多次启动同一个Activity时，系统会创建多个实例，并把它们按照先进后出的原则一一放入任务栈中，当我们按back键时，就会有一个activity从任务栈顶移除，重复下去，直到任务栈为空，系统就会回收这个任务栈。但是这样以来，系统多次启动同一个Activity时就会重复创建多个实例，这种做法显然不合理，为了能够优化这个问题，Android提供四种启动模式来修改系统这一默认行为。 
       进入正题，Activity的四种启动模式如下： 
       standard、singleTop、singleTask、singleInstance 
       接下来，我们一边讲理论一边结合案例来全面学习这四种启动模式。 
       为了打印方便，定义一个基础Activity，在其onCreate方法和onNewIntent方法中打印出当前Activity的日志信息，主要包括所属的task，当前类的hashcode，以及taskAffinity的值。之后我们进行测试的Activity都直接继承该Activity

import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * 方便打印的基础Activity
 */
public class BaseActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        Log.i("WooYun", "*****onCreate()方法******");
        Log.i("WooYun", "onCreate：" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
        Log.i("WooYun", "*****onNewIntent()方法*****");
        Log.i("WooYun", "onNewIntent：" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

protected void dumpTaskAffinity(){
try {
            ActivityInfo info = this.getPackageManager()
                    .getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.i("WooYun", "taskAffinity:"+info.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

standard-默认模式

       这个模式是默认的启动模式，即标准模式，在不指定启动模式的前提下，系统默认使用该模式启动Activity，每次启动一个Activity都会重写创建一个新的实例，不管这个实例存不存在，这种模式下，谁启动了该模式的Activity，该Activity就属于启动它的Activity的任务栈中。这个Activity它的onCreate()，onStart()，onResume()方法都会被调用。 
配置形式：

<activity android:name=".standard.StandardActivity" android:launchMode="standard" > 
 
 
  • 1

使用案例： 
       对于standard模式，android:launchMode可以不进行声明，因为默认就是standard。 
       StandardActivity 的代码如下，入口Activity中有一个按钮进入该Activity，这个Activity中又有一个按钮启动StandardActivity。

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * Standard模式
*/
public class ActivityStandard extends BaseActivity  {
private Buttonjump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_standard);

jump= (Button) findViewById(R.id.btn_standard);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivityStandard.this, ActivityStandard.class);
                startActivity(intent);
            }
        });
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

       我们首先进入StandardActivity，进入后再点击进入Standard的按钮，再按四次返回键不断返回。

这里写图片描述

输出的日志如下：

这里写图片描述

       可以看到日志输出了四次StandardActivity的和一次MainActivity的，从MainActivity进入StandardActivity一次，后来我们又按了三次按钮，总共四次StandardActivity的日志，并且所属的任务栈的id都是2087，这也验证了谁启动了该模式的Activity，该Activity就属于启动它的Activity的任务栈中这句话，因为启动StandardActivity的是MainActivity，而MainActivity的taskId是2087，因此启动的StandardActivity也应该属于id为2087的这个task，后续的3个StandardActivity是被StandardActivity这个对象启动的，因此也应该还是2087，所以taskId都是2087。并且每一个Activity的hashcode都是不一样的，说明他们是不同的实例，即“每次启动一个Activity都会重写创建一个新的实例”

singleTop-栈顶复用模式

       这个模式下，如果新的activity已经位于栈顶，那么这个Activity不会被重写创建，同时它的onNewIntent方法会被调用，通过此方法的参数我们可以去除当前请求的信息。如果栈顶不存在该Activity的实例，则情况与standard模式相同。需要注意的是这个Activity它的onCreate()，onStart()方法不会被调用，因为它并没有发生改变。 
配置形式：

<activity android:name=".singletop.SingleTopActivity" android:launchMode="singleTop">
 
 
  • 1

使用案例： 
ActivitySingleTop.java

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * SingleTop模式
*/
public class ActivitySingleTop extends BaseActivity {
private Button jump,jump2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_singletop);

jump = (Button) findViewById(R.id.btn_singletop);
jump2 = (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTop.this, ActivitySingleTop.class);
                startActivity(intent);
            }
        });
jump2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTop.this, OtherTopActivity.class);
                startActivity(intent);
            }
        });
    }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

OtherTopActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 */
public class OtherTopActivity extends BaseActivity {
private Button jump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other);

jump= (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(OtherTopActivity.this, ActivitySingleTop.class);
                startActivity(intent);
            }
        });
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

操作和standard模式类似，直接贴输出日志

这里写图片描述

       我们看到，除了第一次进入SingleTopActivity这个Activity时，输出的是onCreate方法中的日志，后续的都是调用了onNewIntent方法，并没有调用onCreate方法，并且四个日志的hashcode都是一样的，说明栈中只有一个实例。这是因为第一次进入的时候，栈中没有该实例，则创建，后续的三次发现栈顶有这个实例，则直接复用，并且调用onNewIntent方法。那么假设栈中有该实例，但是该实例不在栈顶情况又如何呢？ 
       我们先从MainActivity中进入到SingleTopActivity，然后再跳转到OtherActivity中，再从OtherActivity中跳回SingleTopActivity，再从SingleTopActivity跳到SingleTopActivity中，看看整个过程的日志。

这里写图片描述

这里写图片描述

这里写图片描述

       我们看到从MainActivity进入到SingleTopActivity时，新建了一个SingleTopActivity对象，并且task id与MainActivity是一样的，然后从SingleTopActivity跳到OtherActivity时，新建了一个OtherActivity，此时task中存在三个Activity，从栈底到栈顶依次是MainActivity，SingleTopActivity，OtherActivity，此时如果再跳到SingleTopActivity，即使栈中已经有SingleTopActivity实例了，但是依然会创建一个新的SingleTopActivity实例，这一点从上面的日志的hashCode可以看出，此时栈顶是SingleTopActivity，如果再跳到SingleTopActivity，就会复用栈顶的SingleTopActivity，即会调用SingleTopActivity的onNewIntent方法。这就是上述日志的全过程。 
对以上内容进行总结 
       standard启动模式是默认的启动模式，每次启动一个Activity都会新建一个实例不管栈中是否已有该Activity的实例。 
singleTop模式分3种情况

  1. 当前栈中已有该Activity的实例并且该实例位于栈顶时，不会新建实例，而是复用栈顶的实例，并且会将Intent对象传入，回调onNewIntent方法
  2. 当前栈中已有该Activity的实例但是该实例不在栈顶时，其行为和standard启动模式一样，依然会创建一个新的实例
  3. 当前栈中不存在该Activity的实例时，其行为同standard启动模式

       standard和singleTop启动模式都是在原任务栈中新建Activity实例，不会启动新的Task，即使你指定了taskAffinity属性。 
那么什么是taskAffinity属性呢，可以简单的理解为任务相关性。

  • 这个参数标识了一个Activity所需任务栈的名字，默认情况下，所有Activity所需的任务栈的名字为应用的包名
  • 我们可以单独指定每一个Activity的taskAffinity属性覆盖默认值
  • 一个任务的affinity决定于这个任务的根activity（root activity）的taskAffinity
  • 在概念上，具有相同的affinity的activity（即设置了相同taskAffinity属性的activity）属于同一个任务
  • 为一个activity的taskAffinity设置一个空字符串，表明这个activity不属于任何task

       很重要的一点taskAffinity属性不对standard和singleTop模式有任何影响，即时你指定了该属性为其他不同的值，这两种启动模式下不会创建新的task（如果不指定即默认值，即包名） 
指定方式如下：

<activity android:name=".ActivitySingleTop" android:launchMode="singleTop" android:taskAffinity="com.castiel.demo.singletop"/>
 
 
  • 1
<activity android:name=".ActivityStandard" android:launchMode="standard" android:taskAffinity="com.castiel.demo.standard"/>
 
 
  • 1

singleTask-栈内复用模式

       这个模式十分复杂，有各式各样的组合。在这个模式下，如果栈中存在这个Activity的实例就会复用这个Activity，不管它是否位于栈顶，复用时，会将它上面的Activity全部出栈，并且会回调该实例的onNewIntent方法。其实这个过程还存在一个任务栈的匹配，因为这个模式启动时，会在自己需要的任务栈中寻找实例，这个任务栈就是通过taskAffinity属性指定。如果这个任务栈不存在，则会创建这个任务栈。 
配置形式：

<activity android:name=".singleTask.SingleTaskActivity" android:launchMode="singleTask" >
 
 
  • 1

使用案例： 
ActivitySingleTask.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * SingleTask模式
*/
public class ActivitySingleTask extends BaseActivity {
private Button jump,jump2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_task);

jump = (Button) findViewById(R.id.btn_task);
jump2 = (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTask.this, ActivitySingleTask.class);
startActivity(intent);
            }
        });
jump2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTask.this, OtherTaskActivity.class);
startActivity(intent);
            }
        });
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

OtherTaskActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 */
public class OtherTaskActivity extends BaseActivity {
private Button jump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other_task);

jump= (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(OtherTaskActivity.this, ActivitySingleTask.class);
                startActivity(intent);
            }
        });
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

       现在我们先不指定任何taskAffinity属性，对它做类似singleTop的操作，即从入口MainActivity进入SingleTaskActivity，然后跳到OtherActivity，再跳回到SingleTaskActivity。看看整个过程的日志。

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

       当我们从MainActiviyty进入到SingleTaskActivity，再进入到OtherActivity后，此时栈中有3个Activity实例，并且SingleTaskActivity不在栈顶，而在OtherActivity跳到SingleTaskActivity时，并没有创建一个新的SingleTaskActivity，而是复用了该实例，并且回调了onNewIntent方法。并且原来的OtherActivity出栈了，具体见下面的信息，使用命令adb shell dumpsys activity activities可进行查看

这里写图片描述

       可以看到当前栈中只有两个Activity，即原来栈中位于SingleTaskActivity 之上的Activity都出栈了。 
       我们看到使用singleTask启动模式启动一个Activity，它还是在原来的task中启动。其实是这样的，我们并没有指定taskAffinity属性，这说明和默认值一样，也就是包名，当MainActivity启动时创建的Task的名字就是包名，因为MainActivity也没有指定taskAffinity，而当我们启动SingleTaskActivity ，首先会寻找需要的任务栈是否存在，也就是taskAffinity指定的值，这里就是包名，发现存在，就不再创建新的task，而是直接使用。当该task中存在该Activity实例时就会复用该实例，这就是栈内复用模式。 
       这时候，如果我们指定SingleTaskActivity 的taskAffinity值。

<activity android:name=".ActivitySingleTask" android:launchMode="singleTask" android:taskAffinity="com.castiel.demo.singletask"/>
 
 
  • 1

还是之前的操作。但是日志就会变得不一样。

这里写图片描述

       我们看到SingleTaskActivity所属的任务栈的TaskId发生了变换，也就是说开启了一个新的Task，并且之后的OtherActivity也运行在了该Task上 
打印出信息也证明了存在两个不同的Task

这里写图片描述

如果我们指定MainActivity的taskAffinity属性和SingleTaskActivity一样，又会出现什么情况呢。

这里写图片描述

没错，就是和他们什么都不指定是一样的。 
这时候，就有了下面的结论 
singleTask启动模式启动Activity时，首先会根据taskAffinity去寻找当前是否存在一个对应名字的任务栈

  • 如果不存在，则会创建一个新的Task，并创建新的Activity实例入栈到新创建的Task中去
  • 如果存在，则得到该任务栈，查找该任务栈中是否存在该Activity实例 
                  如果存在实例，则将它上面的Activity实例都出栈，然后回调启动的Activity实例的onNewIntent方法 
                  如果不存在该实例，则新建Activity，并入栈 
    此外，我们可以将两个不同App中的Activity设置为相同的taskAffinity，这样虽然在不同的应用中，但是Activity会被分配到同一个Task中去。 
    我们再创建另外一个应用，指定它的taskAffinity和之前的一样，都是com.xingyu.demo.singletask
<activity android:name=".MainActivity" android:launchMode="singleTask" android:taskAffinity="com.castiel.demo.singletask"/>
 
 
  • 1

然后启动一个应用，让他跳转到该Activity后，再按home键后台，启动另一个应用再进入该Activity，看日志

这里写图片描述

       我们看到，指定了相同的taskAffinity的SingleTaskActivity和OtherActivity被启动到了同一个task中，taskId都为2169。

singleInstance-全局唯一模式

       该模式具备singleTask模式的所有特性外，与它的区别就是，这种模式下的Activity会单独占用一个Task栈，具有全局唯一性，即整个系统中就这么一个实例，由于栈内复用的特性，后续的请求均不会创建新的Activity实例，除非这个特殊的任务栈被销毁了。以singleInstance模式启动的Activity在整个系统中是单例的，如果在启动这样的Activiyt时，已经存在了一个实例，那么会把它所在的任务调度到前台，重用这个实例。 
配置形式：

<activity android:name=".singleinstance.SingleInstanceActivity" android:launchMode="singleInstance" >
 
 
  • 1

使用案例： 
增加一个Activity如下： 
ActivitySingleInstance.java

import android.os.Bundle;

/**
 * Created by huangshuai on 2016/5/24.
 * Email：huangshuai@wooyun.org
 * SingleInstance模式
 */
public class ActivitySingleInstance extends BaseActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_singleinstance);
    }
}
配置属性如下：
<activity
    android:name=".ActivitySingleInstance"
    android:launchMode="singleInstance">

    <intent-filter>
        <action android:name="com.castiel.demo.singleinstance" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

使用下面的方式分别在两个应用中启动它

Intent intent = new Intent();
intent.setAction("com.castiel.demo.singleinstance");
startActivity(intent);
 
 
  • 1
  • 2
  • 3

做的操作和上一次是一样的，查看日志

这里写图片描述

       我们看到，第一个应用启动SingleInstanceActivity时，由于系统中不存在该实例，所以新建了一个Task，按home键后，使用另一个App进入该Activity，由于系统中已经存在了一个实例，不会再创建新的Task，直接复用该实例，并且回调onNewIntent方法。可以从他们的hashcode中可以看出这是同一个实例。因此我们可以理解为：SingleInstance模式启动的Activity在系统中具有全局唯一性。


       最近有几位朋友给我留言，让我谈一下对Activity启动模式的理解。我觉得对某个知识点的理解必须要动手操作才能印象深刻，所以今天写一篇博文，结合案例理解Activity启动模式。由于之前看过“区长”的一篇博文（文章结尾处有链接）深受启发，因此本文是在那篇文章的基础上更加全面的讲解。 
       众所周知当我们多次启动同一个Activity时，系统会创建多个实例，并把它们按照先进后出的原则一一放入任务栈中，当我们按back键时，就会有一个activity从任务栈顶移除，重复下去，直到任务栈为空，系统就会回收这个任务栈。但是这样以来，系统多次启动同一个Activity时就会重复创建多个实例，这种做法显然不合理，为了能够优化这个问题，Android提供四种启动模式来修改系统这一默认行为。 
       进入正题，Activity的四种启动模式如下： 
       standard、singleTop、singleTask、singleInstance 
       接下来，我们一边讲理论一边结合案例来全面学习这四种启动模式。 
       为了打印方便，定义一个基础Activity，在其onCreate方法和onNewIntent方法中打印出当前Activity的日志信息，主要包括所属的task，当前类的hashcode，以及taskAffinity的值。之后我们进行测试的Activity都直接继承该Activity

import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * 方便打印的基础Activity
 */
public class BaseActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        Log.i("WooYun", "*****onCreate()方法******");
        Log.i("WooYun", "onCreate：" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
        Log.i("WooYun", "*****onNewIntent()方法*****");
        Log.i("WooYun", "onNewIntent：" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

protected void dumpTaskAffinity(){
try {
            ActivityInfo info = this.getPackageManager()
                    .getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.i("WooYun", "taskAffinity:"+info.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

standard-默认模式

       这个模式是默认的启动模式，即标准模式，在不指定启动模式的前提下，系统默认使用该模式启动Activity，每次启动一个Activity都会重写创建一个新的实例，不管这个实例存不存在，这种模式下，谁启动了该模式的Activity，该Activity就属于启动它的Activity的任务栈中。这个Activity它的onCreate()，onStart()，onResume()方法都会被调用。 
配置形式：

<activity android:name=".standard.StandardActivity" android:launchMode="standard" > 
  
  
  • 1

使用案例： 
       对于standard模式，android:launchMode可以不进行声明，因为默认就是standard。 
       StandardActivity 的代码如下，入口Activity中有一个按钮进入该Activity，这个Activity中又有一个按钮启动StandardActivity。

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * Standard模式
*/
public class ActivityStandard extends BaseActivity  {
private Buttonjump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_standard);

jump= (Button) findViewById(R.id.btn_standard);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivityStandard.this, ActivityStandard.class);
                startActivity(intent);
            }
        });
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

       我们首先进入StandardActivity，进入后再点击进入Standard的按钮，再按四次返回键不断返回。

这里写图片描述

输出的日志如下：

这里写图片描述

       可以看到日志输出了四次StandardActivity的和一次MainActivity的，从MainActivity进入StandardActivity一次，后来我们又按了三次按钮，总共四次StandardActivity的日志，并且所属的任务栈的id都是2087，这也验证了谁启动了该模式的Activity，该Activity就属于启动它的Activity的任务栈中这句话，因为启动StandardActivity的是MainActivity，而MainActivity的taskId是2087，因此启动的StandardActivity也应该属于id为2087的这个task，后续的3个StandardActivity是被StandardActivity这个对象启动的，因此也应该还是2087，所以taskId都是2087。并且每一个Activity的hashcode都是不一样的，说明他们是不同的实例，即“每次启动一个Activity都会重写创建一个新的实例”

singleTop-栈顶复用模式

       这个模式下，如果新的activity已经位于栈顶，那么这个Activity不会被重写创建，同时它的onNewIntent方法会被调用，通过此方法的参数我们可以去除当前请求的信息。如果栈顶不存在该Activity的实例，则情况与standard模式相同。需要注意的是这个Activity它的onCreate()，onStart()方法不会被调用，因为它并没有发生改变。 
配置形式：

<activity android:name=".singletop.SingleTopActivity" android:launchMode="singleTop">
  
  
  • 1

使用案例： 
ActivitySingleTop.java

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * SingleTop模式
*/
public class ActivitySingleTop extends BaseActivity {
private Button jump,jump2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_singletop);

jump = (Button) findViewById(R.id.btn_singletop);
jump2 = (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTop.this, ActivitySingleTop.class);
                startActivity(intent);
            }
        });
jump2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTop.this, OtherTopActivity.class);
                startActivity(intent);
            }
        });
    }
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

OtherTopActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 */
public class OtherTopActivity extends BaseActivity {
private Button jump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other);

jump= (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(OtherTopActivity.this, ActivitySingleTop.class);
                startActivity(intent);
            }
        });
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

操作和standard模式类似，直接贴输出日志

这里写图片描述

       我们看到，除了第一次进入SingleTopActivity这个Activity时，输出的是onCreate方法中的日志，后续的都是调用了onNewIntent方法，并没有调用onCreate方法，并且四个日志的hashcode都是一样的，说明栈中只有一个实例。这是因为第一次进入的时候，栈中没有该实例，则创建，后续的三次发现栈顶有这个实例，则直接复用，并且调用onNewIntent方法。那么假设栈中有该实例，但是该实例不在栈顶情况又如何呢？ 
       我们先从MainActivity中进入到SingleTopActivity，然后再跳转到OtherActivity中，再从OtherActivity中跳回SingleTopActivity，再从SingleTopActivity跳到SingleTopActivity中，看看整个过程的日志。

这里写图片描述

这里写图片描述

这里写图片描述

       我们看到从MainActivity进入到SingleTopActivity时，新建了一个SingleTopActivity对象，并且task id与MainActivity是一样的，然后从SingleTopActivity跳到OtherActivity时，新建了一个OtherActivity，此时task中存在三个Activity，从栈底到栈顶依次是MainActivity，SingleTopActivity，OtherActivity，此时如果再跳到SingleTopActivity，即使栈中已经有SingleTopActivity实例了，但是依然会创建一个新的SingleTopActivity实例，这一点从上面的日志的hashCode可以看出，此时栈顶是SingleTopActivity，如果再跳到SingleTopActivity，就会复用栈顶的SingleTopActivity，即会调用SingleTopActivity的onNewIntent方法。这就是上述日志的全过程。 
对以上内容进行总结 
       standard启动模式是默认的启动模式，每次启动一个Activity都会新建一个实例不管栈中是否已有该Activity的实例。 
singleTop模式分3种情况

  1. 当前栈中已有该Activity的实例并且该实例位于栈顶时，不会新建实例，而是复用栈顶的实例，并且会将Intent对象传入，回调onNewIntent方法
  2. 当前栈中已有该Activity的实例但是该实例不在栈顶时，其行为和standard启动模式一样，依然会创建一个新的实例
  3. 当前栈中不存在该Activity的实例时，其行为同standard启动模式

       standard和singleTop启动模式都是在原任务栈中新建Activity实例，不会启动新的Task，即使你指定了taskAffinity属性。 
那么什么是taskAffinity属性呢，可以简单的理解为任务相关性。

  • 这个参数标识了一个Activity所需任务栈的名字，默认情况下，所有Activity所需的任务栈的名字为应用的包名
  • 我们可以单独指定每一个Activity的taskAffinity属性覆盖默认值
  • 一个任务的affinity决定于这个任务的根activity（root activity）的taskAffinity
  • 在概念上，具有相同的affinity的activity（即设置了相同taskAffinity属性的activity）属于同一个任务
  • 为一个activity的taskAffinity设置一个空字符串，表明这个activity不属于任何task

       很重要的一点taskAffinity属性不对standard和singleTop模式有任何影响，即时你指定了该属性为其他不同的值，这两种启动模式下不会创建新的task（如果不指定即默认值，即包名） 
指定方式如下：

<activity android:name=".ActivitySingleTop" android:launchMode="singleTop" android:taskAffinity="com.castiel.demo.singletop"/>
  
  
  • 1
<activity android:name=".ActivityStandard" android:launchMode="standard" android:taskAffinity="com.castiel.demo.standard"/>
  
  
  • 1

singleTask-栈内复用模式

       这个模式十分复杂，有各式各样的组合。在这个模式下，如果栈中存在这个Activity的实例就会复用这个Activity，不管它是否位于栈顶，复用时，会将它上面的Activity全部出栈，并且会回调该实例的onNewIntent方法。其实这个过程还存在一个任务栈的匹配，因为这个模式启动时，会在自己需要的任务栈中寻找实例，这个任务栈就是通过taskAffinity属性指定。如果这个任务栈不存在，则会创建这个任务栈。 
配置形式：

<activity android:name=".singleTask.SingleTaskActivity" android:launchMode="singleTask" >
  
  
  • 1

使用案例： 
ActivitySingleTask.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 * SingleTask模式
*/
public class ActivitySingleTask extends BaseActivity {
private Button jump,jump2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_task);

jump = (Button) findViewById(R.id.btn_task);
jump2 = (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTask.this, ActivitySingleTask.class);
startActivity(intent);
            }
        });
jump2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTask.this, OtherTaskActivity.class);
startActivity(intent);
            }
        });
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

OtherTaskActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email：huangshuai@wooyun.org
 */
public class OtherTaskActivity extends BaseActivity {
private Button jump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other_task);

jump= (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(OtherTaskActivity.this, ActivitySingleTask.class);
                startActivity(intent);
            }
        });
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

       现在我们先不指定任何taskAffinity属性，对它做类似singleTop的操作，即从入口MainActivity进入SingleTaskActivity，然后跳到OtherActivity，再跳回到SingleTaskActivity。看看整个过程的日志。

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

       当我们从MainActiviyty进入到SingleTaskActivity，再进入到OtherActivity后，此时栈中有3个Activity实例，并且SingleTaskActivity不在栈顶，而在OtherActivity跳到SingleTaskActivity时，并没有创建一个新的SingleTaskActivity，而是复用了该实例，并且回调了onNewIntent方法。并且原来的OtherActivity出栈了，具体见下面的信息，使用命令adb shell dumpsys activity activities可进行查看

这里写图片描述

       可以看到当前栈中只有两个Activity，即原来栈中位于SingleTaskActivity 之上的Activity都出栈了。 
       我们看到使用singleTask启动模式启动一个Activity，它还是在原来的task中启动。其实是这样的，我们并没有指定taskAffinity属性，这说明和默认值一样，也就是包名，当MainActivity启动时创建的Task的名字就是包名，因为MainActivity也没有指定taskAffinity，而当我们启动SingleTaskActivity ，首先会寻找需要的任务栈是否存在，也就是taskAffinity指定的值，这里就是包名，发现存在，就不再创建新的task，而是直接使用。当该task中存在该Activity实例时就会复用该实例，这就是栈内复用模式。 
       这时候，如果我们指定SingleTaskActivity 的taskAffinity值。

<activity android:name=".ActivitySingleTask" android:launchMode="singleTask" android:taskAffinity="com.castiel.demo.singletask"/>
  
  
  • 1

还是之前的操作。但是日志就会变得不一样。

这里写图片描述

       我们看到SingleTaskActivity所属的任务栈的TaskId发生了变换，也就是说开启了一个新的Task，并且之后的OtherActivity也运行在了该Task上 
打印出信息也证明了存在两个不同的Task

这里写图片描述

如果我们指定MainActivity的taskAffinity属性和SingleTaskActivity一样，又会出现什么情况呢。

这里写图片描述

没错，就是和他们什么都不指定是一样的。 
这时候，就有了下面的结论 
singleTask启动模式启动Activity时，首先会根据taskAffinity去寻找当前是否存在一个对应名字的任务栈

  • 如果不存在，则会创建一个新的Task，并创建新的Activity实例入栈到新创建的Task中去
  • 如果存在，则得到该任务栈，查找该任务栈中是否存在该Activity实例 
                  如果存在实例，则将它上面的Activity实例都出栈，然后回调启动的Activity实例的onNewIntent方法 
                  如果不存在该实例，则新建Activity，并入栈 
    此外，我们可以将两个不同App中的Activity设置为相同的taskAffinity，这样虽然在不同的应用中，但是Activity会被分配到同一个Task中去。 
    我们再创建另外一个应用，指定它的taskAffinity和之前的一样，都是com.xingyu.demo.singletask
<activity android:name=".MainActivity" android:launchMode="singleTask" android:taskAffinity="com.castiel.demo.singletask"/>
  
  
  • 1

然后启动一个应用，让他跳转到该Activity后，再按home键后台，启动另一个应用再进入该Activity，看日志

这里写图片描述

       我们看到，指定了相同的taskAffinity的SingleTaskActivity和OtherActivity被启动到了同一个task中，taskId都为2169。

singleInstance-全局唯一模式

       该模式具备singleTask模式的所有特性外，与它的区别就是，这种模式下的Activity会单独占用一个Task栈，具有全局唯一性，即整个系统中就这么一个实例，由于栈内复用的特性，后续的请求均不会创建新的Activity实例，除非这个特殊的任务栈被销毁了。以singleInstance模式启动的Activity在整个系统中是单例的，如果在启动这样的Activiyt时，已经存在了一个实例，那么会把它所在的任务调度到前台，重用这个实例。 
配置形式：

<activity android:name=".singleinstance.SingleInstanceActivity" android:launchMode="singleInstance" >
  
  
  • 1

使用案例： 
增加一个Activity如下： 
ActivitySingleInstance.java

import android.os.Bundle;

/**
 * Created by huangshuai on 2016/5/24.
 * Email：huangshuai@wooyun.org
 * SingleInstance模式
 */
public class ActivitySingleInstance extends BaseActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_singleinstance);
    }
}
配置属性如下：
<activity
    android:name=".ActivitySingleInstance"
    android:launchMode="singleInstance">

    <intent-filter>
        <action android:name="com.castiel.demo.singleinstance" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

使用下面的方式分别在两个应用中启动它

Intent intent = new Intent();
intent.setAction("com.castiel.demo.singleinstance");
startActivity(intent);
  
  
  • 1
  • 2
  • 3

做的操作和上一次是一样的，查看日志

这里写图片描述

       我们看到，第一个应用启动SingleInstanceActivity时，由于系统中不存在该实例，所以新建了一个Task，按home键后，使用另一个App进入该Activity，由于系统中已经存在了一个实例，不会再创建新的Task，直接复用该实例，并且回调onNewIntent方法。可以从他们的hashcode中可以看出这是同一个实例。因此我们可以理解为：SingleInstance模式启动的Activity在系统中具有全局唯一性。

ailiya521
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AndroidActivity的四大启动模式详解
02-02
Activity启动模式设置：1.standard模式启动模式，每次激活Activity时都会创建Activity，并放入任务栈中。2.singleTop如果在任务的栈顶正好存在该Activity的实例，就重用该实例，否者就会创建新的实例并放入栈顶(即使...
Activity的四种模式
Windyhsl的博客
06-05 2043
Activity有四种模式：standard(标准启动模式)、singleTop（栈顶复用模式）、singleTask（栈内复用模式）、singleInstance（单实例模式） 看到一个讲解清晰的Activity模式介绍，用来学习。 首先说下什么是Activity，按照我的理解，我们在手机上看到的每一个页面都是一个Activity，包括系统的桌面，也是一个Activity。 要启动一个Activity有四种模式：standard(标准启动模式)、singleTop、singleTask、singleIns
温故知新—Activity的五种启动模式
Zhujiang
07-21 3230
这两天遇到了一个 bug ，和 Activity 的启动模式有关，正好在 Android 12 之后四种启动模式改为了五种，那就一块来看看 Android 的五种启动模式吧！
Activity的四种启动模式
热门推荐
Ai1114的博客
06-10 4万+
系统默认的启动模式，栈结构，先进后出，打开一个activity入栈，再打开下个activity,接着入栈，我们平时直接创建的Activity都是这种模式的Activity这种模式的Activity的特点是：只要你创建了Activity实例，一旦激活该Activity，则会向任务栈中加入新创建的实例，退出Activity则会在任务栈中销毁该实例。如果某个Activity自己激活自己，即任务栈栈顶就是该Activity，则不需要创建，其余情况都要创建Activity实例；如果要激活的那个Activity在任务栈
Android集合和数据的相互转换
UrasakiNakajima的博客
06-15 613
如有需要可以把String换成其他类。
二、Activity 的启动模式
丶一个有梦想的老实人 的博客
05-07 2186
一、四种启动模式： ① standard（标准模式） 这个是系统的默认模式。在这种模式下，每次启动一个 Activity 都会重新创建一个新的实例，不管这个实例是否已经存在，并且谁启动了这个 Activity，那么这个 Activity 就运行在启动它的那个 Activity 所在的栈中。 eg: // FirstActivity.java Intent intent =...
详解Android中Activity的四大启动模式实验简述
08-31
本篇文章主要介绍了Android中Activity的四大启动模式实验简述，具有一定的参考价值，有兴趣的可以了解一下。
Android Activity启动模式全面解析
09-02
主要介绍了Android Activity启动模式全面解析的相关资料,需要的朋友可以参考下
Activity 四种启动模式详细介绍
01-05
Activity 四种启动模式详细介绍 ...Activity启动模式设置： <activity android:name=.MainActivity android:launchMode=standard> <activity android:name=.MainActivity android:launchMode
Android中activity的启动模式
08-31
本文主要介绍了Android中activity的启动模式。具有很好的参考价值，下面跟着小编一起来看下吧
Android Activity启动模式之standard实例详解
09-02
主要介绍了Android Activity启动模式之standard,结合实例形式较为详细的分析了Android中活动(Activity)四种启动模式中的standard相关注意事项与实现技巧,需要的朋友可以参考下
Android Activity启动模式之singleTask实例详解
09-02
主要介绍了Android Activity启动模式之singleTask,结合实例形式较为详细的分析了singleTask模式的功能、使用方法与相关注意事项,需要的朋友可以参考下
Android Activity启动模式之singleTop实例详解
09-02
主要介绍了Android Activity启动模式之singleTop,结合实例形式较为详细的分析了singleTop模式的功能、使用方法与相关注意事项,需要的朋友可以参考下
如何正确理解和使用Activity的4种启动模式
01-04
关于Activity启动模式的文章已经很多，但有的文章写得过于简单，有的则过于注重细节，本文想取一个折中，只关注最重要和最常用的概念，原理和使用方法，便于读者正确应用。 Activity的启动模式有4种，分别是standard...
Android编程中Activity的四种启动模式
09-02
主要介绍了Android编程中Activity的四种启动模式,较为详细的分析了Activity四种启动模式的原理与功能,需要的朋友可以参考下
Android四大组件之Activity（三）—— Activity启动中涉及到的重要的数据结构，ActivityRecord等
aaqian1的博客
01-24 1330
1、使用的是Android 7.1.2的源代码： https://pan.baidu.com/s/1XcVD68cC_2wKtm8jJkdNQA przv 2、感谢IT先森的系列博客： Android应用进程创建流程大揭秘 Android四大组件之bindService源码实现详解 Android四大组件之Activity启动流程源码实现详解概要 Activity启动流程(一)发起端进程请求启动目标Activity Activity启动流程(二)system_server进程处理启动Activity请
安卓基础知识之Activity篇（二）：Activity四大启动模式
qq_40987010的博客
11-10 2284
安卓基础知识之Activity篇（二）：Activity四大启动模式 安卓基础知识系列旨在提供面试或工作中常用的基础知识，让对安卓还不太熟悉的小伙伴更快地入门。同时自己在工作中，也没法完全记住所有的基础细节，写一篇这样系列，可以给自己日后留个知识参考。 开始的开始 安卓四大组件中，最常用的组件莫过于我们的 Activity 组件。安卓程序员每天都在直接或间接地接触着 Activity，所以 Activity 基础知识的重要性不言而喻。   正文 Activity有四种启动模式： Standard：标准
Android 中Activity的四种启动模式
路宇的博客
08-09 6338
Activity的android:launchMode属性： standard:标准模式，默认 singleTop:Task栈顶复用模式 singleTask:Task栈内复用模式 singleInstance:全局单例模式 Activity的管理模式： standard:Activity是由任务栈管理的，每启动一个Activity，就会被放入栈中，按返回键，就会从栈顶移除一个Activity。 具体详解: standard是默认的启动模式，即标准模式，每启动一个Activity，都会创建一个新的实例
详解Activity的四种启动模式
weixin_30248399的博客
12-30 64
　　在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。 Activity启动模式设置：<activity android:name=".MainActivity" android:launchMode="standard" /> A...
Activity 的 启动模式
最新发布
05-09
Android中Activity的启动模式有以下几种： 1. standard（标准模式）：默认的启动模式，每次启动Activity都会创建一个新的实例，并放入任务栈中。 2. singleTop（栈顶复用模式）：在启动Activity时，如果该Activity...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值