我打算做这样的事情:

private static SharedPreferences sharedPreferencesInstance;
public static SharedPreferences getSharedPreferences(final Context context){
    if (context==null)
        return sharedPreferencesInstance;
    if (sharedPreferencesInstance == null)
        sharedPreferencesInstance = context.getApplicationContext().getSharedPreferences("prefs", Context.MODE_PRIVATE);
    return sharedPreferencesInstance;
}

private static SharedPreferences.Editor sharedPreferencesEditorInstance;
public static SharedPreferences.Editor getSharedPreferencesEditor(final Context context){
    if (context==null)
        return sharedPreferencesEditorInstance;
    if (sharedPreferencesEditorInstance == null)
        sharedPreferencesEditorInstance = context.getApplicationContext().getSharedPreferences("prefs", Context.MODE_PRIVATE).edit();
    return sharedPreferencesEditorInstance;
}

但是它在上下文泄漏的意义上是安全的吗？

最佳答案

为了权威地回答这个问题，将 SharedPreferences 实例存储为静态引用是安全的。根据 javadocs，它是一个单例，所以它来自 getSharedPreferences 的源代码已经是一个静态引用。

存储 SharedPreferences.Editor 是不安全的，因为两个线程可能同时操作同一个编辑器对象。诚然，如果您碰巧已经这样做了，那么这将造成的损害相对较小。相反，在每个编辑方法中获取一个编辑器的实例。

我强烈建议对您的Application 对象使用静态引用，而不是在每次获取时都传入Context 对象。 Application 类的所有实例无论如何都是每个进程的单例，并且传递 Context 对象通常是不好的做法，因为它往往会通过引用持有导致内存泄漏，而且这是不必要的冗长。

最后，如果您应该延迟加载或贪婪地初始化对静态 SharedPreferences 的引用，要回答这个未提出的问题，您应该延迟加载静态 getter 方法。根据类导入链，可能使用 final static SharedPreferences sReference = YourApplication.getInstance().getSharedPreferences() 贪婪地初始化引用，但这将是对于类加载器来说，在 Application 调用 onCreate(您将在其中初始化 YourApplication 引用)之前初始化引用太容易了，导致空指针异常。总结:

class YourApplication {
    private static YourApplication sInstance;

    public void onCreate() {
        super.onCreate();
        sInstance = this;
    }
    public static YourApplication get() {
        return sInstance;
    }
}

class YourPreferencesClass {
    private static YourPreferencesClass sInstance;
    private final SharedPreferences mPrefs;

    public static YourPreferencesClass get() {
        if (sInstance == null)
            sInstance = new YourPreferencesClass();
        return sInstance;
    }

    private final YourPreferencesClass() {
        mPrefs = YourApplication.get().getSharedPreferences("Prefs", 0);
    }

    public void setValue(int value) {
        mPrefs.edit().putInt("value", value).apply();
    }

    public int getValue() {
        return mPrefs.getInt("value", 0);
    }
}

然后您将使用静态可用的首选项类:

YourPreferencesClass.get().setValue(1);

关于线程安全和内存可观察性的最后一句话。一些敏锐的观察者可能会注意到 YourPreferencesClass.get() 不是同步的，因此很危险，因为两个线程可能会初始化两个不同的对象。但是，您可以安全地避免同步。正如我之前提到的，getSharedPreferences 已经返回单个静态引用，因此即使在极少数情况下 sInstance 被设置两次，对 SharedPreferences<> 被使用。对于 YourApplication.sInstance 的静态实例，没有同步或 volatile 关键字也是安全的。在 YourApplication.onCreate 之前运行的应用程序中没有用户线程，因此为新创建的线程定义的 happens-before 关系确保静态引用对所有可能访问该引用的 future 线程可见.

关于android - 保留对 SharedPreferences 及其编辑器的静态引用是否安全？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22544466/