java - 静态对象(例如单例)会泄漏非静态上下文吗？为什么？

Question

这可能听起来像一个愚蠢的问题，但我正在单例和访问共享首选项的 POJO 两种设计模型之间切换，并且我想阻止任何内存。上下文方面的泄漏。

我知道静态对象被分配到堆，但是对于单例设计来说，类保持非静态并声明自身的静态实例并实例化它，如果这个实例被传递上下文来执行某种类型的方法，

• 它会泄露这个上下文吗？
• 如果不是，为什么不，如果是，为什么以及如何解决？

这是我创建的当前单例设计

public class UserSettings {
  private UserSettings settings = new UserSettings();

  private UserSettings() {
    }

    public static UserSettings getInstance() {
        return settings;
    }

    private SharedPreferences getPrefs(Context context) {
        return context.getSharedPreferences(
                USER_SETTINGS_FILE,
                Context.MODE_PRIVATE
        );
    }

    private SharedPreferences.Editor getEditor(Context context) {
        return context.getSharedPreferences(
                USER_SETTINGS_FILE,
                Context.MODE_PRIVATE
        ).edit();
    }

    public Object get(Context context,int item) {
        SharedPreferences sp = getPrefs(context);
        switch (item) {
            case TIMING:
                return sp.getInt(KEY_USER_TIMING,60);
            case NAME:
                return sp.getString(KEY_USER_NAME,"Stranger");
            // .. etc
            default:
                return 0;
        }
    }

    public void update(Context context,int setting, Object updateValue) throws ClassCastException {
        SharedPreferences.Editor sp = getPrefs(context).edit();
        switch (setting) {
            case TIMING:
                if (Integer.class.isInstance(updateValue))
                    sp.putInt(KEY_USER_TIMING,(int)updateValue).commit();
                else
                    throw new ClassCastException("User Time must be int");
                break;
            case NAME:
                if (String.class.isInstance(updateValue))
                    sp.putString(KEY_USER_NAME,(String)updateValue).commit();
                else
                    throw new ClassCastException("User Name must be String");
                break;
           // .... etc
            default:
                break;
        }
    }

}

Answer 1

如果您不创建对上下文的引用，而是将其传递给每个方法调用，则它不会泄漏，因为它不会被保留。如果您在其生命周期之外存储了对上下文的引用，那么您只会泄漏上下文。例如，如果我存储使用 Activity 上下文来静态初始化单例。即使 Activity 消失，上下文对象也不会最终确定，因为在某处仍然存在对它的引用。

但是，有几种设计模式可以巧妙地完成此任务。我一般用Dagger

这不会导致上下文泄漏，因为 Singleton SharedPreferencesHelper 的生命周期与应用程序的生命周期相关，并且它使用应用程序上下文。

自定义应用程序.java

private static ObjectGraph staticRefToObjectGraph;

@Override
public void onCreate() {
    super.onCreate();

    staticRefToObjectGraph = ObjectGraph.create(new MyModule(this));
}

public static void inject(Object obj) {
    staticRefToObjectGraph.inject(obj);
}

MyModule.java

public MyModule(Context applicationContext) {
    SharedPreferences prefs = PreferenceManager.getSharedPreferences(applicationContext);
    prefsHelper = new SharedPreferencesHelper(prefs);
}

@Provides
@Singleton
public SharedPreferencesHelper providePrefsHelper() {
    return prefsHelper;
}

MyActivity.java

@Inject SharedPreferencesHelper prefsHelper

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