如何一次退出多个Activity

有下面几种方法：

1.使用链表把要退出的Activity实例保存起来，在要退出时，遍例这个链表，调用每个Activity的finish方法。

      在应用程序的每个 Activity 里面的 onCreate() 或者 onStart() 里面把当前的的 Activity 加入该栈中（ addActivity ），在你需要退出 activity 的时候，调用下面对应的方法去销毁栈。

     不过这样有一个问题，如果你的应用程序有很多个Activity，那么加栈的这个代码就要重复写很多次，为了偷懒，可以选择写一个Activity的子类（比如BaseActivity）,之后的该应用程序里的所有Activity都继承你写的

BaseActivity，在BaseActivity里面的onCreate()或者onStart()里面把当前的的Activity加入该栈中（addActivity），这样会省去很多代码的。（AppManager.getInstance().addActivity(this);）

import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;
import java.util.Stack;

/**
 * app管理类 对应用的activity进行控制
 *
 * @author Huangnan
 */

public class AppManager {

    private static AppManager manager;
    private Stack<Activity> activityStack;
    private AppManager() {
    }
    //单例
    public static  AppManager getInstance() {

        if (manager == null) {
            synchronized (AppManager.class) {
                if (manager == null) {
                    manager = new AppManager();
                }
            }
        }
        return manager;
    }

    /**
     * 添加Activity到堆栈
     */
    // Stack <Activity> activityStack;
    public void addActivity(Activity activity) {
        if (activityStack == null) {
            activityStack = new Stack<Activity>();
        }
        activityStack.add(activity);
    }

    /**
     * 获取当前Activity（堆栈中最后一个压入的）
     */
    public Activity currentActivity() {
        Activity activity = activityStack.lastElement();
        return activity;
    }

    /**
     * 结束当前Activity（堆栈中最后一个压入的）
     */
    public void finishActivity() {
        Activity activity = activityStack.lastElement();
        finishActivity(activity);
    }

    /**
     * 结束指定的Activity
     */
    public void finishActivity(Activity activity) {
        if (activity != null) {
            activityStack.remove(activity);
            activity.finish();
            activity = null;
        }
    }

    /**
     * 结束指定类名的Activity
     */
    public void finishActivity(Class<?> cls) {
        for (Activity activity : activityStack) {
            if (activity.getClass().equals(cls)) {
                finishActivity(activity);
            }
        }
    }

    /**
     * 结束所有Activity
     */
    public void finishAllActivity() {
        for (int i = 0; i < activityStack.size(); i++) {
            if (null != activityStack.get(i)) {
                activityStack.get(i).finish();
            }
        }
        activityStack.clear();
    }

    /**
     * 退出应用程序
     */
    public void AppExit(Context context) {
        try {
            finishAllActivity();
            ActivityManager activityMgr = (ActivityManager) context
                    .getSystemService(Context.ACTIVITY_SERVICE);
            activityMgr.killBackgroundProcesses(context.getPackageName());
            System.exit(0);
        } catch (Exception e) {
        }
    }
}

2.可以使用广播，每个Activity中收到这个广播，自己把自己finish掉。 

public abstract class EnterActivity extends BaseActivity {


    // 写一个广播的内部类，当收到动作时，结束activity
    private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            unregisterReceiver(this); // 这句话必须要写要不会报错，不写虽然能关闭，会报一堆错
            ((Activity) context).finish();
        }
    };

    @Override
    public void onResume() {
        super.onResume();
        // 在当前的activity中注册广播
        IntentFilter filter = new IntentFilter();
        filter.addAction(Attribute.PAGENAME);
        registerReceiver(this.broadcastReceiver, filter); // 注册
    }

    /**
     * 关闭
     */
    public void close() {
        Intent intent = new Intent();
        intent.setAction(Attribute.PAGENAME); // 说明动作
        sendBroadcast(intent);// 该函数用于发送广播
        finish();
    }
}

之后的activity继承BaseActivity

3.可以在要退出Activity的onStart方法中加入以下code:

MyApplication mApp = (MyApplication)getApplication();
mApp.setExit(true);
finish();

4.假如Activity的启动顺序是：A->B->C->D,我们想在D中把所有的Acitivity都清理掉，那么做法是：

  A的Manifest.xml配置成android:launchMode="singleTop" ，D窗口打开A窗口的Intent加入标识Intent.FLAG_ACTIVITY_CLEAR_TOP，这样会把栈中B， C，D都清除掉，同时因为A是的启动模式是singleTop，不会调用onCreate，而是调用onNewIntent,这时判断intent的值，如果为Intent.FLAG_ACTIVITY_CLEAR_TOP，则把A finish掉，这样A，B，C，D都finish掉了。

5.如果Activity的启动顺序是：A->B->C->D，可以把A的起动模式设成singleTask

从D起动A,会把栈中位于A之上的Activity都kill掉，然后在A的onNewIntent中把A finish掉。

最好是加入标识，通过判断来执行，这样安全一点，也就是在D开启A的时候，加intent.setFlags(xxx);xxx为自定义int型常量，

Intent intent = new Intent(D.this, A.class);
intent.setFlags(9009);
startActivity(intent);

在A中的onNewIntent()里面判断，是要销毁整个应用程序的指令时才把自己finish掉。

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    if(intent.getFlags()==9009){      
	finish();
    }}

其实我的感觉，singleTask和singleTop的做法和理论都差不多。

上面是几种方法，应该都可以，具体的应用就要看场景了。