Android退出应用程序方法总结

在Android开发中，我们运行了应用程序后，都需要退出应用的，那么该如何退出应用，又都有哪些实现方式呢？今天就为大家整理分享一些退出应用程序的方法，一起来看看吧！

更新内容

Ver：v1

任务管理器方法补充

新增监听式退出方法

Ver：v2

任务管理器方法修正

新增销毁任务栈退出方法

----

1. finish方法

finish();

该方法只是结束当前Activity，系统将最上面的Activity移出了栈，并没有清理占用的资源。如果栈内有很多Activity 的话，使用该方法显得有点捉襟见肘了，没办法一次移出全部Activity，并且没有立即释放内存，活动的资源也没有被清理。

2. 进程式

KillProcess()：
可以杀死当前应用活动的进程，这一操作将会把所有该进程内的资源（包括线程全部清理掉）。当然，由于ActivityManager时刻监听着进程，一旦发现进程被非正常Kill，它将会试图去重启这个进程。

android.os.Process.killProcess(android.os.Process.myPid());

System.exit()：
Java中结束进程的方法，调用它将关闭当前的JVM虚拟机。

System.exit(0);//正常退出

System.exit(1);//非正常退出

KillProcess() 和 System.exit()，许多人都使用过，当你栈里只有一个Activity的时候，这个措施是行之有效的。但当关闭多个Activity的时候，栈里有多个Activity时，这两个方法就不起作用了。
因为通过杀进程方式退出，会被系统认为异常退出，会保存应用的一些状态信息比如Activity运行栈，然后会恢复这个应用。当恢复一个Android应用程序时，会先从栈里面移除异常的Activity，相当于Back键操作。

3. 根据Activity的生命周期

Android的窗口类提供了历史栈，可以通过stack的原理来巧妙的实现。在A窗口打开B窗口的时候，在Intent中直接加入标识Intent.FLAG_ACTIVITY_CLEAR_TOP，这样开启B时，会清除该进程空间的所有Activity。
1）在A窗口中调用该方法跳转到B窗口：

Intent intent = new Intent();

intent.setClass(AActivity.this,BActivity.class);

intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

startActivity(intent);

2）在B窗口退出时直接使用 finish 方法即可全部退出

finish();

4. 任务管理器

系统将终止一切和这个程序包关联的，所有共享同一 uid 的 process全部杀掉，还会停止相关的服务，并且会发送一个广播。

ActivityManager am = (ActivityManager)getSystemService (Context.ACTIVITY_SERVICE);

am.restartPackage(getPackageName());

但是在 Android 2.2（API 8）之后，restartPackage方法已经过时，不可以将应用程序结束，需要使用ActivityManager类的killBackgroundProcesses方法。

ActivityManager am = (ActivityManager)getSystemService (Context.ACTIVITY_SERVICE);

am.killBackgroundProcesses(getPackageName());

System.exit(0);

注意事项：该方法虽然可以立即杀死与指定包相关联的所有后台进程，但是这些进程如果在将来某一时刻需要使用，便会重新启动。而且该方法只是结束后台进程的方法，不能结束当前应用移除所有的 Activity。如果需要退出应用，需要添加System.exit(0)方法一起使用，并且只限栈内只有一个Activity，如果有多个Activity时，正如上面 方法 2 所说，就不起作用了。

5. 任务栈式

利用一个单例模式的Activity栈来管理所有Activity
1）自定义 Application类，储存每一个Activity，并实现关闭所有Activity的操作

public class MyApplication extends Application {    

    private List activityList = new LinkedList();

    private static MyApplication instance;





/**

*单例模式 1:

*/

    private MyApplication() {

    }



    public static MyApplication getInstance() {

        if(null == instance) {

            instance = new MyApplication();

        }

        return instance;

    }



    @Override

    public void onCreate() {

        super.onCreate();

    }

    

    

/**

*单例模式 2:

*/

//  public static MyApplication getInstance() {

//        return instance;

//  }



//   @Override

//    public void onCreate() {

//        super.onCreate();

//        instance = this;        

//    }

    



   //添加Activity到容器中

    public void addActivity(Activity activity)  {

        activityList.add(activity);

    }

    

   //遍历所有Activity并finish

    public void exit() {

        for(Activity activity:activityList) {

            activity.finish();

        }       

        activityList.clear();

    }

}

2）在父类BaseActivity中添加继承子类Activity到栈中

public class BaseActivity extends Activity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // 添加Activity到堆栈

        MyApplication.getInstance().addActivity(this);

    }

    ...

}

3）在需要结束所有Activity的时候调用 exit 方法

MyApplication.getInstance().exit();

6. 容器式

类似 5（任务栈式），自定义一个Actiivty栈，通过单例模式的Activity栈来管理所有Activity
1）建立一个全局容器，把所有的Activity存储起来

public class BaseActivity extends Activity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // 添加Activity到堆栈

        AtyContainer.getInstance().addActivity(this);

    }

    ...

}

2）创建Activity管理类

public class AtyContainer {



    public AtyContainer() {

    }



    private static AtyContainer instance = new AtyContainer();

    private static List activityStack = new ArrayList();

    public static AtyContainer getInstance() {

        return instance;

    }



    /**

     * 添加Activity到堆栈

     */

    public void addActivity(Activity activity) {

        if (activityStack == null) {

            activityStack = new ArrayList();

        }

        activityStack.add(activity);

    }



    /**

     * 移除指定的Activity

     */

    public void removeActivity(Activity activity) {

        if (activity != null) {

            activityStack.remove(activity);

            activity = null;

        }

    }

    /**

    * 结束所有Activity

    */

    public void finishAllActivity() {

        for (int i = 0, size = activityStack.size(); i < size; i++) {

            if (null != activityStack.get(i)) {

                activityStack.get(i).finish();

            }

        }

        activityStack.clear();

    }

}

3）在退出时循环遍历finish所有Activity

 AtyContainer.getInstance().finishAllActivity();

方法 5（任务栈式）和 6（容器式），是目前许多人常用的，但是需要注意的是：activityStack持有Activity的强引用，当某个Activity异常退出时，activityStack没有及时释放掉引用，可能会导致内存问题。

7. 清空堆栈

1）设置MainActivity的加载模式为singleTask

android:launchMode="singleTask"

2）重写MainActivity中的onNewIntent方法

@Override

protected void onNewIntent(Intent intent) {

    super.onNewIntent(intent);

    if (intent != null) {

        boolean isExit = intent.getBooleanExtra("exit", false);

        if (isExit) {

            finish();

        }

    }

}

3）需要退出时在Intent中添加退出的Tag

/**退出程序*/

protected void exit() {

    // 这里使用clear + new task的方式清空整个任务栈,只保留新打开的Main页面

    // 然后Main页面接收到退出的标志位exit=true,finish自己,这样就关闭了全部页面

    Intent intent = new Intent(this, MainActivity.class);

    intent.putExtra("exit", true);

    startActivity(intent);

}

8. 销毁任务栈

直接调用系统 API获取当前的任务栈，把里面的Activity全部销毁掉。不过该方法简单粗暴，需要 API 21（Android 5.0）以上才可以使用。

@TargetApi(Build.VERSION_CODES.LOLLIPOP)

    private void exitAPP() {

        ActivityManager activityManager = (ActivityManager) context.getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);

        List appTaskList = activityManager.getAppTasks();

        for (ActivityManager.AppTask appTask : appTaskList) {

            appTask.finishAndRemoveTask();

        }

    }

9. 广播式

通过在全局中注册一个广播，当退出时发送一个广播退出
1）在BaseActivity中注册广播

public class BaseActivity extends Activity {



    private static final String EXITACTION = "action.exit";

    private ExitReceiver exitReceiver = new ExitReceiver();



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        IntentFilter filter = new IntentFilter();

        filter.addAction(EXITACTION);

        registerReceiver(exitReceiver, filter);

    }



    @Override

    protected void onDestroy() {

        super.onDestroy();

        unregisterReceiver(exitReceiver);

    }



    class ExitReceiver extends BroadcastReceiver {

        @Override

        public void onReceive(Context context, Intent intent) {

            finish();

        }

    }



}

2）发送广播退出

public class MainActivity extends BaseActivity {

    private long exitTime = 0;

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

    }

// 物理返回键，双击退出

    @Override

    public boolean onKeyDown(int keyCode, KeyEvent event) {

        if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {

            if ((System.currentTimeMillis() - exitTime) > 2000) {

                Toast.makeText(MainActivity.this, "再按一次退出程序", Toast.LENGTH_SHORT).show();

                exitTime = System.currentTimeMillis();

            } else {

                //发送广播退出程序

                Intent intent = new Intent("com.xxx.BaseActivity");

                intent.putExtra(EXITACTION, 1);

                sendBroadcast(intent);

            }

            return true;

        }

        return super.onKeyDown(keyCode, event);

    }

}

10. 懒人式

1）将MainActivity设置为singleTask

android:launchMode="singleTask"

2）将退出出口放置在MainActivity

private boolean mIsExit;

/**双击返回键退出*/

@Override

public boolean onKeyDown(int keyCode, KeyEvent event) {

    if (keyCode == KeyEvent.KEYCODE_BACK) {

        if (mIsExit) {

            this.finish();

        } else {

            Toast.makeText(MainActivity.this, "再按一次退出程序", Toast.LENGTH_SHORT).show();

            mIsExit = true;

            new Handler().postDelayed(new Runnable() {

                @Override

                public void run() {

                    mIsExit = false;

                }

            }, 2000);

        }

        return true;

    }

    return super.onKeyDown(keyCode, event);

}

...

11. 退回系统桌面

Android应用开发中，有一种场景，就是我们不希望用户直接按Back键退出Activity，而是希望应用隐藏到后台的假退出，类似于按Home键的效果。（例如QQ、微信等）

方法一：

moveTaskToBack(true);//将Activity退到后台，注意不是finish()退出。

方法二：

/**退出程序**/

protected void exit() {

    Intent startMain = new Intent(Intent.ACTION_MAIN);

    startMain.addCategory(Intent.CATEGORY_HOME);

    startMain.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    startActivity(startMain);

    System.exit(0);

}

方法三：

    package="com.xxx.xxx"   

    android:versionCode="1"

    android:versionName="1.0.1">

       

    
        android:name="com.xxx.xxx.MainActivity"

        android:label="@string/app_name"

        android:launchMode="singleTask"

        android:clearTaskOnLaunch="true"

        android:stateNotNeeded="true">

        

            

            

            

        

     

   ...

  

12. 监听式

从Android 4.0（API 14）开始，Application中多了一个可以设置全局监听Activity生命周期的方法：registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback)，其中传入的参数 ActivityLifecycleCallbacks能得到全局所有Activity生命周期的回调，所以我们可以从Application中全局监听所有Activity并对其进行管理

public class MyApplication extends Application {

    protected static Context context;   



    /**

     * 维护Activity 的list

     */

    private static List mActivitys = Collections.synchronizedList(new LinkedList());



    @Override

    public void onCreate() {

        super.onCreate();

        context = this.getApplicationContext();

        registerActivityListener();

    }



    public static Context getContext() {

        return context;

    }



    /**

     * @param activity 作用说明 ：添加一个activity到管理里

     */

    public void pushActivity(Activity activity) {

        mActivitys.add(activity);

    }



    /**

     * @param activity 作用说明 ：删除一个activity在管理里

     */

    public void popActivity(Activity activity) {

        mActivitys.remove(activity);

    }



    /**

     * get current Activity 获取当前Activity（栈中最后一个压入的）

     */

    public static Activity currentActivity() {

        if (mActivitys == null||mActivitys.isEmpty()) {

            return null;

        }

        Activity activity = mActivitys.get(mActivitys.size()-1);

        return activity;

    }



    /**

     * 结束当前Activity（栈中最后一个压入的）

     */

    public static void finishCurrentActivity() {

        if (mActivitys == null||mActivitys.isEmpty()) {

            return;

        }

        Activity activity = mActivitys.get(mActivitys.size()-1);

        finishActivity(activity);

    }



    /**

     * 结束指定的Activity

     */

    public static void finishActivity(Activity activity) {

        if (mActivitys == null||mActivitys.isEmpty()) {

            return;

        }

        if (activity != null) {

            mActivitys.remove(activity);

            activity.finish();

            activity = null;

        }

    }



    /**

     * 结束指定类名的Activity

     */

    public static void finishActivity(Class cls) {

        if (mActivitys == null||mActivitys.isEmpty()) {

            return;

        }

        for (Activity activity : mActivitys) {

            if (activity.getClass().equals(cls)) {

                finishActivity(activity);

            }

        }

    }



    /**

     * 按照指定类名找到activity

     *

     * @param cls

     * @return

     */

    public static Activity findActivity(Class cls) {

        Activity targetActivity = null;

        if (mActivitys != null) {

            for (Activity activity : mActivitys) {

                if (activity.getClass().equals(cls)) {

                    targetActivity = activity;

                    break;

                }

            }

        }

        return targetActivity;

    }



    /**

     * @return 作用说明 ：获取当前最顶部activity的实例

     */

    public Activity getTopActivity() {

        Activity mBaseActivity = null;

        synchronized (mActivitys) {

            final int size = mActivitys.size() - 1;

            if (size < 0) {

                return null;

            }

            mBaseActivity = mActivitys.get(size);

        }

        return mBaseActivity;



    }



    /**

     * @return 作用说明 ：获取当前最顶部的acitivity 名字

     */

    public String getTopActivityName() {

        Activity mBaseActivity = null;

        synchronized (mActivitys) {

            final int size = mActivitys.size() - 1;

            if (size < 0) {

                return null;

            }

            mBaseActivity = mActivitys.get(size);

        }

        return mBaseActivity.getClass().getName();

    }



    /**

     * 结束所有Activity

     */

    public static void finishAllActivity() {

        if (mActivitys == null) {

            return;

        }

        for (Activity activity : mActivitys) {

            activity.finish();

        }

        mActivitys.clear();

    }



    /**

     * 退出应用程序

     */

    public  static void appExit() {

        try {

            finishAllActivity();

        } catch (Exception e) {

        }

    }



    private void registerActivityListener() {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {

            registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {

                @Override

                public void onActivityCreated(Activity activity, Bundle savedInstanceState) {

                    /**

                     *  监听到 Activity创建事件 将该 Activity 加入list

                     */

                    pushActivity(activity);

                }



                @Override

                public void onActivityStarted(Activity activity) {



                }



                @Override

                public void onActivityResumed(Activity activity) {



                }



                @Override

                public void onActivityPaused(Activity activity) {



                }



                @Override

                public void onActivityStopped(Activity activity) {



                }



                @Override

                public void onActivitySaveInstanceState(Activity activity, Bundle outState) {



                }



                @Override

                public void onActivityDestroyed(Activity activity) {

                    if (null==mActivitys||mActivitys.isEmpty()) {

                        return;

                    }

                    if (mActivitys.contains(activity)) {

                        /**

                         *  监听到 Activity销毁事件 将该Activity 从list中移除

                         */

                        popActivity(activity);

                    }

                }

            });

        }

    }



}

结语

----

以上整理了目前Android退出应用程序常见的一些方法，每个方法各有利弊，大家可以去实践下，看看其具体效果，然后根据自己的需要，选择适合自己的方式。