探究Android中的活动

目录

• 新建一个空项目
• 在活动中使用Toast
• 在活动中使用Menu
• 使用intent使得活动之间得以跳转
• 活动的生命周期
  • 返回栈
  • 活动状态
    • 1. 运行状态
    • 2. 暂停状态
    • 3. 停止状态
    • 4. 销毁状态
  • 活动的生命周期
  • 体验活动的生命周期
• 活动的启动模式
  • standard
  • singleTop
  • singleTask
  • singleInstance

新建一个空项目

在Android Studio中创建一个没有主活动的项目，即选Add no Activity。

创建好之后，在com.example.emptypro目录下新建一个Activity即FirstActivity.java活动文件:

其初始的代码应如下：

package com.example.emptypro;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
}

很简单。

  然后在res目录下新建directory目录layout，再在layout目录下新建布局文件first_layout.xml，将里面的内容改为：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

<!-- 这里引用id的写法可以参见xml文件中引用资源文件的写法，即@id/button_1，这是表示引用xml文件中的id名，而@+id/button_1则表示在xml文件中新定义一条id名 -->
    <Button  android:id="@+id/button_1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button 1" />

</LinearLayout>

将上述布局文件设为主界面：

public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.first_layout)
        // 项目中添加的任何资源文件都会在R内置类中生成一个相应的资源id(静态常量)，在java文件中都是通过引用的都是这个资源id来间接引用资源文件的
    }
}

在活动中使用Toast

  Toast是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，这些信息会在一段时间后自动消失，并且不会占用任何屏幕空间。

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.first_layout)
    Button button1 = (Button) findViewById(R.id.button_1);
    button1.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            // makeText(Context, msg, duration)
            // context表示上下文对象，即Toast依附的活动
            // msg是Toast显示的信息
            // duration是Toast持续的时间，有两个内置常量供选，Toast.LENGTH_SHORT和Toast.LENGTH_LONG
            Toast.makeText(FirstActivity.this, "You clicked Button 1", Toast.LENGTH_SHORT).show()
        }
    })
}

  Toast的使用非常简单，调用Toast类的静态方法makeText()创建出一个Toast对象，然后调用show()将Toast显示出来就可以了。

在活动中使用Menu

  手机毕竟和电脑不同，它的屏幕空间非常有限，因此充分利用屏幕空间在手机界面设计中就显得十分重要。如果你的活动中有大量的菜单需要显示，这个时候界面设计就会比较尴尬，因为仅这些菜单就可能占用屏幕将近三分之一的空间。Android给我们提供了一种方式，可以让菜单都能得到展示的同时，还能不占用任何屏幕空间。

在res目录下新建menu目录，再在menu目录下新建菜单文件main.xml，将其中的内容改为：

<?xml version="1.0" encoding="utf-8"?>
<!-- item是菜单中的条目 -->
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:id="@+id/add_item"
        android:title="Add" />
    <item
        android:id="@+id/remove_item"
        android:title="Remove" />
</menu>

  然后再在firstActivity类中重写onCreateOptionMenu()方法(使在main.xml中写好了的菜单得以作为真正的菜单显示在App中)和onOptionsItemSelected()方法(定义菜单响应事件)

public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.first_layout);
        Button button1 = (Button)findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(FirstActivity.this, "You clicked Button 1", Toast.LENGTH_SHORT).show();
            }
        });
    }
    
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        //  return super.onCreateOptionsMenu(menu);
        getMenuInflater().inflate(R.menu.main, menu);
        // getMenuInflater()方法得到MenuInflater对象，再调用它的inflate()方法给当前活动创建菜单
        // inflate(通过哪一个资源文件来创建菜单, 该菜单项将添加到哪一个Menu对象中)
        return true;    // 返回true表示允许创建的菜单显示出来，如果返回了false则创建的菜单将无法显示
    }
    
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // 使用item.getItemId()能判断我们点击的是哪一个菜单项
        switch (item.getItemId()) {
            case R.id.add_item:
                Toast.makeText(this, "You clickd Add", Toast.LENGTH_SHORT).show();
                break;
            case R.id.remove_item:
                Toast.makeText(this, "You clicked Remove", Toast.LENGTH_SHORT).show();
                break;
        }
        return true;
    }
}

使用intent使得活动之间得以跳转

  首先在上面项目的基础上再创建一个活动SecondActivity，勾选自动创建布局文件，会在layout目录中自动生成一个second_layout.xml文件，将其中的内容替换为：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button  android:id="@+id/button_2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button 2" />

</LinearLayout>

至于SecondActivity.java嘛，直接使用默认的就好了。

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.second_layout);
    }
}

  在项目中使用的任何活动都需要在Manifest.xml中注册，不过这一步在创建活动时Android Studio帮我们自动注册了。

  Intent是Android程序中各部件之间进行交互的一种重要方式，它不仅可以指明当前组件想要执行的动作，还可以在不同组件之间传递数据。Intent一般可用于启动活动，启动服务以及发送广播等场景。

Intent大致可分为两种：显示Intent和隐式Intent。

先来看看显示Intent。

  Intent有多个构造函数的重载，其中一个就是Intent(Context packageContext, Class<?> cls)，这个构造函数接收两个参数，第一个参数context要求提供一个启动活动的上下文，第二个参数Class则要指定想要启动的目标活动。通过这两个参数Intent就能构建出它的“意图”了。

  Activity类中提供了一个参数startActivity()方法，这个方法是专门用于启动活动的，它接收一个Intent参数，将Intent构建好后传给它就可以启动目标活动了。

将FirstActivity中按钮的点击事件改为：

button1.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
       Intent intent = new Intent(FirstActivity.this, SecondActivty.class);
       startActivity(intent);
   }
});

按下Back键就可以销毁当前活动从而返回上一个活动(即手机的回退键)。

活动的生命周期

  掌握活动的生命周期对任何Android开发者来说都非常重要，当你深入理解活动的生命周期之后，就可以写出连贯流畅的程序，并在如何管理应用资源方面发挥得游刃有余。你的应用程序将会拥有更好的用户体验。

返回栈

  Android中的活动是可以层叠的，活动层叠的基本模型是返回栈。我们每启动一个新的活动，就会覆盖在原活动之上，然后点击Back键会销毁最上面的活动，下面的一个活动就会重新显示出来。

  其实，Android是使用任务(Task)来管理活动的，一个任务就是一组存放在栈里的活动的集合，这个栈也被称为返回栈(Back Stack)。

  栈是一种后进先出的数据结构，在默认情况下，每当我们启动了一个新的活动，它就会在返回栈入栈，并处于栈顶的位置。而每当我们按下Back键或调用finish()方法去销毁一个活动时，处于栈顶的活动会出栈，这时前一个入栈的活动就会重新处于栈顶的位置。而系统总是显示处于栈顶的活动给用户。

下面的示意图展示了返回栈是如何管理活动入栈出栈操作的：

活动状态

每个活动在其生命周期中最多可能会有4种状态。

1. 运行状态

  当一个活动位于返回栈的栈顶时，这时活动就处于运行状态。系统最不愿意回收的就是处于运行状态的活动，因为这会带来非常差的用户体验。

2. 暂停状态

  当一个活动不再处于栈顶位置，但仍然可见时，这时活动就进入了暂停状态。

  你可能会觉得既然活动已经不在栈顶，还怎么会可见呢？这是因为并不是每一个活动都会占满整个屏幕的，比如对话框形式的活动只会占用屏幕中间的部分区域，你很快就会在后面看到这种活动。

  处于暂停状态的活动仍然是完全存活着的，系统也不愿意去回收这种活动(因为它还是可见，回收可见的东西都会在用户体验方面有不好的影响)只有在内存极低的情况下，系统才会去考虑回收这种活动。

3. 停止状态

  当一个活动不再处于栈顶位置，并且完全不可见时，就进入了停止状态。系统仍然会为这种活动保存相应的状态和成员变量，但是这并不是完全可靠的，当其他地方需要内存时，处于停止状态的活动有可能会被系统回收。

4. 销毁状态

  当一个活动从返回栈中移除后就变成了销毁状态。系统会最倾向于回收处于这种状态的活动，从而保证手机的内存充足。

活动的生命周期

  Activity类中定义了7个回调方法，覆盖了活动生命周期的每一个环节，下面来介绍一下这7个方法：

• onCreate()。这个方法你已经看到过很多次，每个活动中我们都重写了这个方法，它会在活动第一次被创建的时候调用。应该在这个方法中完成活动的初始化操作，比如"加载布局"，"绑定事件"。
• onStart()。这个方法在活动由不可见变为可见的时候调用。
• onResume()。这个方法在活动准备好和用户进行交互的时候调用。此时的活动一定位于返回栈的栈顶，并且处于运行状态。
• onPause()。这个方法在系统准备去启动或者恢复另一个活动的时候调用。我们通常会在这个方法中将一些CPU的资源释放掉，以及保存一些关键数据，但这个方法的执行速度一定要快，不然会影响到新的栈顶活动的使用。
• onStop()。这个方法在活动完全不可见的时候调用。它和onPause()方法的主要区别在于，如果启动的新活动是一个对话框式的活动，那么onPause()方法会得到执行，而onStop()方法并不会执行。
• onDestroy()。这个方法在活动被销毁之前调用，之后活动的状态将变为销毁状态。
• onRestart()。这个方法在活动由停止状态变为运行状态之前调用，也就是活动被重新启动了。

  可见，以上7个方法中除了onRestart()方法外，其他都是两两相对的，从而又可以将活动分为3种生存期。

• 完整生存期。活动在onCreate()方法和onDestroy()方法之间所经历的，就是完整生存期。一般情况下，一个活动会在onCreate()方法中完成各种初始化操作，而在onDestory()方法中完成释放内存的操作。
• 可见生存期。活动在onStart()方法和onStop()方法之间所经历的，就是可见生存期。在可见生存期内，活动对于用户总是可见的，即便有可能无法和用户进行交互。我们可以通过这两个方法，合理地管理那些对用户可见的资源。比如在onStart()方法中对资源进行加载，而在onStop()方法中对资源进行释放，从而保证处于停止状态的活动不会占用过多内存。
• 前台生存期。活动在onResume()方法和onPause()方法之间所经历的就是前台生存期。在前台生存期内，活动总是处于运行状态中，此时的活动是可以和用户进行交互的，我们平时看到和接触最多的也就是这个状态下的活动。

Android官方提供了一张活动生命周期示意图，帮助我们更好理解：

体验活动的生命周期

  使用File->new->new Project->Add No Activity新建一个空项目ActivityLifeCycleTest，再在包com.example.activitylifecycletest中新建两个empty Activity，分别为NormalActivity和DialogActivity，再分别为它们新建布局文件normal_ layout.xml和 dialog_layout.xml。

将normal_layout.xml的内容改为：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    
    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="This is a normal activity"/>

</LinearLayout>

再将dialog_layout.xml的内容改为：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="This is a dialog activity"/>

</LinearLayout>

可见，这两个布局文件除了显示的文字内容不同外，其他都一样。

  我们创建DialogActivity活动的目的是让它成为一个对话框活动，但现在NormalActivity和DialogActivity中的内容都是初始状态，怎么区分它们一个为普通活动一个为对话框活动?

答案当然是通过AndroidManifest.xml定义，将该文件里面针对DialogActivity活动的定义改为：

<activity android:name=".DialogActivity"
    android:theme="@style/Theme.AppCompat.Dialog" >
</activity>

这样一来，DialogActivity就被声明为对话框内容了。

  NormalActivity.java和DialogActivity.java中的内容不需要改动，保持默认即可。这里只需要对MainActivity做一些调整即可。先将activity_main.xml中的内容改为：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <!--  用于启动NormalActivity -->
    <Button
        android:id="@+id/start_normal_activity"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start NormalActivity"/>

    <!--  用于启动DialogActivity -->
    <Button
        android:id="@+id/start_dialog_activity"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start DialogActivity"/>

</LinearLayout>

再在MainActivity.java中绑定一些监听事件：

package com.example.activitylifecycletest;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.content.Intent;
import android.util.*;

public class MainActivity extends AppCompatActivity {
    public static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button startNormalActivity = (Button) findViewById(R.id.start_normal_activity);
        Button startDialogActivity = (Button) findViewById(R.id.start_dialog_activity);

        // 为两个按钮添加事件监听(启动相应的活动)，事件绑定要放在onCreate()方法中
        startNormalActivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 从当前类MainActivity跳转到NormalActivity
                Intent intent = new Intent(MainActivity.this, NormalActivity.class);
                startActivity(intent);
            }
        });

        startDialogActivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, DialogActivity.class);
                startActivity(intent);
            }
        });
    }

    // 重写父类的7个生命周期方法，通过Log.d()控制台输出，看活动次此时处于哪个状态
    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "onStart");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "onStop");
    }

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

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

logcat的输出如下：

  MainActivity活动第一次被创建时会依次执行onCreate()，onStart() 和 onResume() 方法。

  先点击第一个按钮，由于NormalActivity活动会将MainActivity活动完全遮盖，因此会执行onPause()和onStop()（MainActivity变为完全不可见，处于停止状态）

再按下Back键返回MainActivity活动，此时会执行：

• onRestart:NormalActivity被销毁，从返回栈弹出，其此时处于销毁状态。MainActivity被重新激活，进入运行状态。
• onStart:MainActivity由不可见变为可见。
• onResume:MainActivity重新回到返回栈的栈顶，准备与用户进行交互。

然后再点击第二个按钮，将会只执行：

• onPause:进入DialogActivity活动，DialogActivity活动此时处于返回栈栈顶。但由于此时DialogActivity并没有完全遮盖住MainActivity活动，所以并不会执行onStop()方法，而只会执行onPause()。

最后在MainActivity中按下Back键，会依次执行：

• onPause:
• onStop():MainActivity活动停止
• onDestory：DialogActivity活动被销毁，从返回栈弹出，销毁之前DialogActivity会调用onDestory()

活动的启动模式

  启动模式一共有4种，分别为standard，singleTop，singleTask和singleInstance，可以在AndroidManifest.xml中通过给标签android:launchMode属性来选择启动模式。

standard

  standard是活动默认的启动模式，在不进行显式指定的情况下，所有活动都会自动使用这种启动模式。

  我们已经知道，Android是使用返回栈来管理活动的。在standard模式(默认模式)下，每当启动一个新的活动，它就会在返回栈中入栈，并处于栈顶的位置。对于使用standard模式的活动，系统不会在乎这个活动是否已经在返回栈中存在，每次启动都会创建该活动的一个新的实例。

将上面例子中emptyPro项目中FirstActivity活动中的onCreate()函数的代码更改如下：

public class FirstActivity extends AppCompatActivity {
    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("FirstActivity", this.toString())
        setContentView(R.layout.first_layout);
        Button button1 = (Button)findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 点击button_1时，在FirstActivity上再新建一个FirstActivity实例
                Intent intent = new Intent(FirstActivity.this, FirstActivity.class);
                startActivity(intent);
            }
        });
    }
    ...
}

  在FirstActivity活动上再新建一个FirstActivity实例着实有点怪，但这确实是可行的，如果我们在FirstActivity界面上连续点击两次button_1按钮，很快就会在logcat中看到如下输出：

  也就是说，每点击一次按钮实际上就创建了一个新的活动实例，standard模式下不好考虑返回栈中是否已经存在这个活动。

singleTop

 &emsp如果将活动的启动模式设为singleTop，在活动启动时如果发现返回栈的栈顶已经是该活动，则认为可以直接使用它(处于栈顶的该活动)，不会再创建新的活动实例。

  在上面那个例子中，如果将启动模式设为singleTop，则无论点击多少次按钮，实际上都只会创建一个FirstActivity活动实例。

  但我们还是可以在上面对singleTop模式的陈述中找到一丝漏洞，那就是如果返回栈中存在该活动单该活动不是处于返回栈栈顶呢？答案是singleTop模式下仍然会创建一个新的活动实例，毕竟不处于返回栈栈顶的该活动无法被直接使用。

还是以emptyPro项目为例子，将FirstActivity活动中的onCreate()方法改为：

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

在将SecondActivity活动中的onCreate()方法改为：

public class SecondActivity extends AppCompatActivity {
    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("SecondActivity", this.toString())
        setContentView(R.layout.first_layout);
        Button button2 = (Button)findViewById(R.id.button_2);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 在FirstActivity界面上点击按钮跳转到SecondActivity活动中
                Intent intent = new Intent(SecondActivity.this, FirstActivity.class);
                startActivity(intent);
            }
        });
    }
    ...
}

  现在我们执行这一串操作：在FirstActivity上点击button_1进入SecondActivity，再在SecondActivity上点击button_2回到FirstActivity，这串操作过程中会输出如下信息：

  可见，当点击SecondActivity中的按钮返回FirstActivity时，虽然返回栈中已经存在FirstActivity活动，但此时处于返回栈栈顶的是SecondActivity，所以还是要创建一个新的FirstActivity实例。

singleTask

  使用singleTop模式可以很好的解决重复创建栈顶活动实例的问题，但正如前面所提到的，当该活动没有处于返回栈栈顶时，还是可能会创建多个活动实例的。

  那么有没有一种方法可以让某个活动在整个应用程序的上下文中只存在一个实例呢？这得借助于singleTask启动模式。

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

  首先在Manifest.xml中将启动模式设为singleTask，保持上例中各活动的onCreate()方法的定义不变，然后在FirstActivity类的定义中添加onRestart()方法，并打印日志：

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

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

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

  重新运行程序，在FirstActivity界面上点击按钮进入到SecondActivity，然后在SecondActivity界面点击按钮，又会重新进入到FirstActivity。在这个过程中Logcat将输出：

  从打印信息中，我们就可以得到一些信息：在SecondActivity中点击按钮启动FirstActivity时，singleTask模式下检查到返回栈中已经存在一个FirstActivity实例，并且它在SecondActivity的下面。于是SecondActivity会从返回栈中出栈，而下面的FirstActivity重新成为了栈顶活动。因此FirstActivity的onRestart()和SecondActivity的onDestroy()方法就会得到执行。

singleInstance

  singleInstance模式可以算是4种启动模式中最特殊也最复杂的一个了。不同于上述所介绍的3种启动模式，指定为singleInstance模式的活动会启用一个新的返回栈来管理这个活动(singleTask模式下，如果指定了不同的taskAffinity，也会创建一个新的返回栈)。

那么这样做(新建一个返回栈)有什么意义呢？

  假设我们的程序中有一个活动是允许其他程序调用的，如果我们想其他程序和我们的程序可以共享这个活动的实例，这应该如果实现呢？

  可见，使用上述介绍的前3种启动模式是做不到的，因为每个应用程序都会有自己的返回栈，同一个活动在不同的返回栈中入栈时必然是创建了新的活动实例，这样一来，共享同一活动实例的愿望就无法达成。

  而使用singleInstance模式就可以解决这个问题，在这种模式下会有一个单独的返回栈来管理这个活动，因此不管是哪个应用程序来访问这个活动，都会共用同一个返回栈，这样也就解决了共享活动实例的问题。

  还是以emptyPro项目为例子，我们首先在AndroidManifest.xml中更改SecondActivity活动的启动模式:

<activity android:name=".SecondActivity" android:launchMode="singleInstance">
    <intent-filter>
        <action android:name="com.example.emptyPro.ACTION_START" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="com.example.emptyPro.MY_CATEGORY" />
    </intent-filter>
</activity>

  将SecondActivity的启动模式指定为singleInstance，然后修改FirstActivity中onCreate()方法的代码：

public class FirstActivity extends AppCompatActivity {
    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 打印当前返回栈的id
        Log.d("FirstActivity", "Task id is " + getTaskId());
        setContentView(R.layout.first_layout);
        Button button1 = (Button)findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });
    }
    ...
}

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

public class SecondActivity extends AppCompatActivity {
    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 打印当前返回栈的id
        Log.d("FirstActivity", "Task id is " + getTaskId());
        setContentView(R.layout.first_layout);
        Button button2 = (Button)findViewById(R.id.button_2);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(SecondActivity.this, ThirdActivity.class);
                startActivity(intent);
            }
        });
    }
    ...
}

新建一个ThirdActivity活动，修改其中onCreate()方法的代码：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 打印当前返回栈的id
    Log.d("ThirdActivity", "Task is " + getTaskId());
    setContentView(R.layout.third_layout);
}

  在FirstActivity界面中点击按钮进入到SecondActivity，然后在SecondActivity界面上再点击按钮进入ThirdActivity。

现在可以查看logcat中的输出信息了。

  可以看到，为SecondActivity指定了singleInstance启动模式之后，它是单独放在一个&返回栈中的，与其他两个活动FirstActivity和ThirdActivity不同。

  然后我们按下Back键进行返回,你会发现ThirdActivity竟然直接返回到了 FirstActivity,再按下Back键又会返回到SecondActivity,再按下Back键才会退出程序,这是为什么呢?

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

singleInstance模式的原理示意图：