Android:Activity的生命周期和启动方式

一、生命周期

返回栈和任务。
任务是一系列Activity的集合。在安卓开发中Activity被安排在返回栈中保存。先进后出的样式。
一般一个任务对应到一个返回栈。当然也可以一个任务对应多个返回栈。

1.启动Activity：系统会先调用onCreate方法，然后调用onStart方法，最后调用onResume，Activity进入运行状态。
2.当前Activity被其他Activity覆盖其上或被锁屏：系统会调用onPause方法，暂停当前Activity的执行。
3.当前Activity由被覆盖状态回到前台或解锁屏：系统会调用onResume方法，再次进入运行状态。
4.当前Activity转到新的Activity界面或按Home键回到主屏，自身退居后台：系统会先调用onPause方法，然后调用onStop方法，进入停滞状态。
5.用户后退回到此Activity：系统会先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，再次进入运行状态。
6.当前Activity处于被覆盖状态或者后台不可见状态，即第2步和第4步，系统内存不足，杀死当前Activity，而后用户退回当前Activity：再次调用onCreate方法、onStart方法、onResume方法，进入运行状态。
7.用户退出当前Activity：系统先调用onPause方法，然后调用onStop方法，最后调用onDestory方法，结束当前Activity。
但是知道这些还不够，我们必须亲自试验一下才能深刻体会，融会贯通。

public class MainActivity extends AppCompatActivity {
    private Button button;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d("Flag","here is Main onCreate()");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        button = (Button)findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this,SecondActivity.class);
                startActivity(intent);
            }
        });
    }
    @Override
    protected void onStart() {
        Log.d("Flag","here is  Main onStart()");
        super.onStart();
    }

    @Override
    protected void onResume() {
        Log.d("Flag","here is Main onResume()");
        super.onResume();
    }

    @Override
    protected void onPause() {
        Log.d("Flag","here is Main onPause()");
        super.onPause();
    }
    @Override
    protected void onRestart() {
        Log.d("Flag","here is Main onRestart()");
        super.onRestart();
    }
    @Override
    protected void onStop() {
        Log.d("Flag","here is Main onStop()");
        super.onStop();
    }
    @Override
    protected void onDestroy() {
        Log.d("Flag","here is Main onDestroy()");
        super.onDestroy();
    }

public class SecondActivity extends AppCompatActivity{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        Log.d("Flag","here is Second onCreate()");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.second);
    }
    @Override
    protected void onStart() {
        Log.d("Flag","here is Second onStart()");
        super.onStart();
    }

    @Override
    protected void onResume() {
        Log.d("Flag","here is Second onResume()");
        super.onResume();
    }

    @Override
    protected void onPause() {
        Log.d("Flag","here is Second onPause()");
        super.onPause();
    }

    @Override
    protected void onRestart() {
        Log.d("Flag","here is Second onRestart()");
        super.onRestart();
    }

    @Override
    protected void onStop() {
        Log.d("Flag","here is Second onStop()");
        super.onStop();
    }


    @Override
    protected void onDestroy() {
        Log.d("Flag","here is Second onDestroy()");
        super.onDestroy();
    }
}

这里我们在MainActivity中放了一个Button,为了让它跳转到SecondActivity中，观察周期函数的输出：

Flag: here is Main onCreate()
Flag: here is Main onStart()
Flag: here is Main onResume()

现在点击按钮：

Flag: here is Main onPause()
Flag: here is Second onCreate()
Flag: here is Second onStart()
Flag: here is Second onResume()
Flag: here is Main onStop()

点击返回键：

Flag: here is Second onPause()
Flag: here is Main onRestart()
here is Main onStart()
here is Main onResume()
here is Second onStop()
here is Second onDestroy()

二、启动方式
(1) standard
standard 是活动默认的启动模式,在不进行显式指定的情况下,所有活动都会自动使用这种启动模式。
在 standard 模式(即默认情 况)下,每当启动一个新的活动,Android总会为启动的Activity创建一个新的实例，并把它返回栈中入栈,并处于栈顶的位置。这种模式不会创建新的Task,只是将新Activity添加到原有的Task 中。

(2)singleTop
如果在任务的栈顶正好存在该Activity的实例， 就重用该实例，否者就会创建新的实例并放入栈顶(即使栈中已经存在该Activity实例，只要不在栈顶，都会创建实例)。

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

(4) singleInstance
这种模式下会有一个单独的返回栈来管理这个活动，不管是哪个应用程序来访问这个活动，都共用的同一个返回栈，也就解决了共享活动实例的问题。
假设B启动A，A启动C，其中A的启动模式为singleInstance，则：