采用Singleton模式实现Android应用的完全退出

最新推荐文章于 2025-09-10 15:46:06 发布

iteye_12827

最新推荐文章于 2025-09-10 15:46:06 发布

阅读量102

点赞数

文章标签：移动开发 java

本文探讨了Android应用在退出时如何优雅地处理多个Activity的退出问题，提出了DalvikVM本地方法、任务管理器方法、历史栈以及采用Singleton模式等四种方案，并详细解释了每种方法的适用场景及优缺点。

对于同时启动了很多Activity的Android应用的完美退出，网上最常用的有三种解决方案，但是每种都有不足之处，如下：

第一种，Dalvik VM的本地方法。

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

2
  
3
System.exit(0);

个人理解这种方式只适合Task中始终只有一个Activity的情形，对于一个以上的情况，它就只能销毁当前的Activity了，而对于在Task中位于这个Activity之下的Activity，个人认为似乎是无能为力。

第二种，任务管理器方法。

1ActivityManager activityMgr = (ActivityManager) getSystemService(ACTIVITY_SERVICE); 

2activityMgr.restartPackage(getPackageName());

注意，这种方式只能用在Android 1.5 API 3以上才可以，同时需要如下权限，而且这种方式Google官方的最新版中好像已经不支持了，因为restartPackage这个方法好像没有了。

1 <uses-permission android:name="android.permission.RESTART_PACKAGES"/>

第三种，历史栈。这种方式可以结合第一种方式来实现特定情形下的应用退出，这种方式的一个最显著地特点就是在启动Activity的Intent中加入Intent.FLAG_ACTIVITY_CLEAR_TOP标记，这个标记的主要作用就是会在task中将你启动的哪个Activity上面的Activity全部销毁掉，这适合于将退出操作放置在应用的第一个Activity中，其他Activity通过使用Intent.FLAG_ACTIVITY_CLEAR_TOP种方式到达第一个Activity后，再从第一个Activity来退出。而对于将退出操作不放在应用的第一个Activity中的这种情况，这种方式就没法解决了。

第四种，采用Singleton模式来处理，这种方式可以说是目前为止最好的解决办法了，它的原理主要是将所有启动的Activity放入一个全局的静态堆栈中，而在程序退出时，一次性销毁堆栈中所有存在的Activity。下面是为了实现这种方式而写的类：

01
package cn.net.toms.client.common; 

02
  

03
import java.util.Stack; 

04
  

05
import android.app.Activity; 

06
  

07
public class ScreenManager { 

08
  

09
    /** 

10
     * 视图管理器，用于完全退出 

11
     *  

12
     * @return 

13
     */

14
    public static ScreenManager getScreenManager() { 

15
        if (instance == null) { 

16
            instance = new ScreenManager(); 

17
        } 

18
        return instance; 

19
    } 

20
  

21
    /** 

22
     * 回收堆栈中指定的activity 

23
     *  

24
     * @param activity 

25
     */

26
    public void popActivity(Activity activity) { 

27
        if (activity != null) { 

28
            activity.finish(); 

29
            activityStack.remove(activity); 

30
            activity = null; 

31
        } 

32
    } 

33
  

34
    /** 

35
     * 获取堆栈的栈顶activity 

36
     *  

37
     * @return 栈顶activity 

38
     */

39
    private Activity currentActivity() { 

40
        Activity activity = null; 

41
        try { 

42
            if (!activityStack.isEmpty()) { 

43
                activity = activityStack.pop(); 

44
            } 

45
            return activity; 

46
        } catch (Exception ex) { 

47
            System.out.println("ScreenManager:currentActivity---->"

48
                    + ex.getMessage()); 

49
            return activity; 

50
        } finally { 

51
            activity = null; 

52
        } 

53
    } 

54
  

55
    /** 

56
     * 将activity压入堆栈 

57
     *  

58
     * @param activity 

59
     *            需要压入堆栈的activity 

60
     */

61
    public void pushActivity(Activity activity) { 

62
        if (activityStack == null) { 

63
            activityStack = new Stack<Activity>(); 

64
        } 

65
        activityStack.push(activity); 

66
    } 

67
  

68
    /** 

69
     * 回收堆栈中所有Activity 

70
     */

71
    public void popAllActivity() { 

72
        Activity activity = null; 

73
        try { 

74
            while (!activityStack.isEmpty()) { 

75
                activity = currentActivity(); 

76
                if (activity != null) { 

77
                    popActivity(activity); 

78
                } 

79
            } 

80
        } finally { 

81
            activity = null; 

82
        } 

83
    } 

84
  

85
    private ScreenManager() { 

86
  

87
    } 

88
  

89
    private static Stack<Activity> activityStack; 

90
    private static ScreenManager instance; 

91}

然后在每个Activity的onCreate方法中加入

1
ScreenManager.getScreenManager().pushActivity(this);

即可将所有Activity放入这个堆栈中。最后我们在程序退出时如下操作，即可完美的退出整个应用。

ScreenManager.getScreenManager().popAllActivity();

注意，以上的四种方式都是在不考虑Activity的finish下的退出。