这里即使把获取SharedPreferences对象的模式改为MODE_MULTI_PROCESS,也仅仅是在Android 3.0以下才有效,在Android 3.0以上也是一样不行的。
源码分析
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
//或者这样
SharedPreferences sharedPreferences = getSharedPreferences("name", Context.MODE_PRIVATE);
public static SharedPreferences getDefaultSharedPreferences(Context context) {
return context.getSharedPreferences(getDefaultSharedPreferencesName(context),
getDefaultSharedPreferencesMode());
}
public abstract SharedPreferences
getSharedPreferences(String name, int mode);
@Override
public SharedPreferences getSharedPreferences(String name, int mode) {
// 如果传入null,将文件名给为"null",即最后会是null.xml
if (mPackageInfo.getApplicationInfo().targetSdkVersion <
Build.VERSION_CODES.KITKAT) {
if (name == null) {
name = "null";
}
}
File file;
synchronized (ContextImpl.class) {
if (mSharedPrefsPaths == null) {
mSharedPrefsPaths = new ArrayMap<>();
}
file = mSharedPrefsPaths.get(name);
if (file == null) {
file = getSharedPreferencesPath(name);
mSharedPrefsPaths.put(name, file);
}
}
return getSharedPreferences(file, mode);
}
@Override
public File getSharedPreferencesPath(String name) {
return makeFilename(getPreferencesDir(), name + ".xml");
}
@Override
public SharedPreferences getSharedPreferences(File file, int mode) {
checkMode(mode);
SharedPreferencesImpl sp;
synchronized (ContextImpl.class) {
//查看缓存中是否存在SharedPreferencesImpl对象,若存在直接返回
final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
sp = cache.get(file);
if (sp == null) {
sp = new SharedPreferencesImpl(file, mode);
cache.put(file, sp);
return sp;
}
}
//若Android版本小于3.0并且mode为MODE_MULTI_PROCESS,则调用startReloadIfChangedUnexpectedly方法重新读取磁盘文件
if ((mode & Context.MODE_MULTI_PROCESS) != 0 ||
getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) {
sp.startReloadIfChangedUnexpectedly();
}
return sp;
}
private ArrayMap<File, SharedPreferencesImpl> getSharedPreferencesCacheLocked() {
//以包名为key进行缓存ArrayMap,存在则直接return
if (sSharedPrefsCache == null) {
sSharedPrefsCache = new ArrayMap<>();
}
final String packageName = getPackageName();
ArrayMap<File, SharedPreferencesImpl> packagePrefs = sSharedPrefsCache.get(packageName);
if (packagePrefs == null) {
packagePrefs = new ArrayMap<>();
sSharedPrefsCache.put(packageName, packagePrefs);
}
return packagePrefs;
}
private void checkMode(int mode) {
//在Android 7.0以上若允许外部读写将直接抛出异常
if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.N) {
if ((mode & MODE_WORLD_READABLE) != 0) {
throw new SecurityException("MODE_WORLD_READABLE no longer supported");
}
if ((mode & MODE_WORLD_WRITEABLE) != 0) {
throw new SecurityException("MODE_WORLD_WRITEABLE no longer supported");
}
}
}
那么这里我们可以有个猜想,即是否只有在创建SharedPreferences对象的时候才会从磁盘中进行读取,读取后的值保存在了内存中,获取SharedPreferences对象优先从缓存中获取,再次创建时才会重新从磁盘中再次读取文件。
我们直接看一下SharedPreferencesImpl的源码,验证一下我们的猜想。
//SharedPreferencesImpl的构造方法
SharedPreferencesImpl(File file, int mode) {
mFile = file;
mBackupFile = makeBackupFile(file);
mMode = mode;
mLoaded = false;
mMap = null;
startLoadFromDisk();
}
private void startLoadFromDisk() {
synchronized (this) {
mLoaded = false;
}
new Thread("SharedPreferencesImpl-load") {
public void run() {
loadFromDisk();
}
}.start();
}
private void loadFromDisk() {
//若已经在加载,直接return
synchronized (SharedPreferencesImpl.this) {
if (mLoaded) {
return;
}
if (mBackupFile.exists()) {
mFile.delete();
mBackupFile.renameTo(mFile);
}
}
// Debugging
if (mFile.exists() && !mFile.canRead()) {
Log.w(TAG, "Attempt to read preferences file " + mFile + " without permission");
}
Map map = null;
StructStat stat = null;
try {
stat = Os.stat(mFile.getPath());
if (mFile.canRead()) {
BufferedInputStream str = null;
try {
str = new BufferedInputStream(
new FileInputStream(mFile), 16*1024);
//使用XmlUtils将xml文件读取后转成一个map对象
map = XmlUtils.readMapXml(str);
} catch (XmlPullParserException | IOException e) {
Log.w(TAG, "getSharedPreferences", e);
} finally {
IoUtils.closeQuietly(str);
}
}
} catch (ErrnoException e) {
/* ignore */
}
synchronized (SharedPreferencesImpl.this) {
//加载完成,状态更新
mLoaded = true;
if (map != null) {
//将map对象赋值给成员变量mMap
mMap = map;
mStatTimestamp = stat.st_mtime;
mStatSize = stat.st_size;
} else {
mMap = new HashMap<>();
}
notifyAll();
}
}
@Nullable
public String getString(String key, @Nullable String defValue) {
synchronized (this) {
//这个方法只要判断是否加载xml文件完毕,防止加载未完成就调用了getString方法
awaitLoadedLocked();
String v = (String)mMap.get(key);
return v != null ? v : defValue;
}
}
public final class EditorImpl implements Editor {
private final Map<String, Object> mModified = Maps.newHashMap();
private boolean mClear = false;
public Editor putString(String key, @Nullable String value) {
synchronized (this) {
mModified.put(key, value);
return this;
}
}
...
public void apply() {
final MemoryCommitResult mcr = commitToMemory();
final Runnable awaitCommit = new Runnable() {
public void run() {
try {
mcr.writtenToDiskLatch.await();
} catch (InterruptedException ignored) {
}
}
};
QueuedWork.add(awaitCommit);
Runnable postWriteRunnable = new Runnable() {
public void run() {
awaitCommit.run();
QueuedWork.remove(awaitCommit);
}
};
SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
// Okay to notify the listeners before it's hit disk
// because the listeners should always get the same
// SharedPreferences instance back, which has the
// changes reflected in memory.
notifyListeners(mcr);
}
public boolean commit() {
MemoryCommitResult mcr = commitToMemory();
SharedPreferencesImpl.this.enqueueDiskWrite(
mcr, null /* sync write on this thread okay */);
try {
mcr.writtenToDiskLatch.await();
} catch (InterruptedException e) {
return false;
}
notifyListeners(mcr);
return mcr.writeToDiskResult;
}
...
private MemoryCommitResult commitToMemory() {
MemoryCommitResult mcr = new MemoryCommitResult();
synchronized (SharedPreferencesImpl.this) {
if (mDiskWritesInFlight > 0) {
//对mMap进行扩容
mMap = new HashMap<String, Object>(mMap);
}
mcr.mapToWriteToDisk = mMap;
mDiskWritesInFlight++;
//判断是否有注册监听者
boolean hasListeners = mListeners.size() > 0;
if (hasListeners) {
mcr.keysModified = new ArrayList<String>();
mcr.listeners =
new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
}
synchronized (this) {
if (mClear) {
if (!mMap.isEmpty()) {
mcr.changesMade = true;
mMap.clear();
}
mClear = false;
}
for (Map.Entry<String, Object> e : mModified.entrySet()) {
//将值添加到SharedPreferences的成员变量mMap中去
String k = e.getKey();
Object v = e.getValue();
if (v == this || v == null) {
if (!mMap.containsKey(k)) {
continue;
}
mMap.remove(k);
} else {
if (mMap.containsKey(k)) {
Object existingValue = mMap.get(k);
if (existingValue != null && existingValue.equals(v)) {
continue;
}
}
mMap.put(k, v);
}
mcr.changesMade = true;
if (hasListeners) {
mcr.keysModified.add(k);
}
}
mModified.clear();
}
}
return mcr;
}
其实通过方法名我们也可以猜到,就是将值提交到内存,从代码上也可以看出来,就是将Editor的所有put进去的值添加到SharedPreferences的mMap成员变量中。
那么最后将内容写入磁盘的方法就是enqueueDiskWrite了,我们看一下它的源码
private void enqueueDiskWrite(final MemoryCommitResult mcr,
final Runnable postWriteRunnable) {
final Runnable writeToDiskRunnable = new Runnable() {
public void run() {
synchronized (mWritingToDiskLock) {
writeToFile(mcr);
}
synchronized (SharedPreferencesImpl.this) {
mDiskWritesInFlight--;
}
if (postWriteRunnable != null) {
postWriteRunnable.run();
}
}
};
final boolean isFromSyncCommit = (postWriteRunnable == null);
// Typical #commit() path with fewer allocations, doing a write on
// the current thread.
if (isFromSyncCommit) {
boolean wasEmpty = false;
synchronized (SharedPreferencesImpl.this) {
wasEmpty = mDiskWritesInFlight == 1;
}
if (wasEmpty) {
writeToDiskRunnable.run();
return;
}
}
QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
}
源码比较简单,其中最主要的就是区分了apply方法调用和commit的调用,apply调用的话会将写入磁盘的任务加入到一个线程池中在后台运行,直接commit的话则会在当前线程进行写入。
总结
整个获取SharedPreferences对象过程的流程图如下
流程总结:
1)当调用PreferenceManager的getSharedPreferences(String name,int mode)方法的时候,会通过该方法参数name(文件名)从ArrayMap中获取对应的File(无的话则创建ArrayMap或在ArrayMap中添加该键值对),然后调用重载方法getSharePreferences(File file,int mode)传入file,该方法中将通过包名从缓存中获取ArrayMap<File,SharedPreferencesImpl>,通过file获取返回SharedPreferencesImpl(接口SharedPreferences的实现类)对象,无则创建SharedPreferencesImpl并加入ArrayMap(若Android版本小于3.0并且mode为MODE_NULTI_PROCESS,则重新读取磁盘文件)
2)当创建SharedPreferencesImpl的时候,会在构造方法中开启一个线程加载磁盘当中的文件并将内容赋值给了成员变量mMap(Map<String,Object>集合),当调用getString等方法时,则是直接从mMap集合中取出值进行返回。
3)当需要进行写入的时候,则需获取接口Editor中的方法(其实现类为EditorImpl)提交方法apply()或commit()都会将所有put进去的值添加到SharedPreferencesImpl的mMap成员变量中,然后再将内容写入磁盘。
(写入的时候会写入内存和磁盘,而获取的时候则从内存中读取,除非重新创建或Android版本小于3.0并且mode为MODE_NULTI_PROCESS,因此造成多进程情况下修改数据后另一进程获取不到改变)
Android的SharedPreferences采用了这种模式,主要还是为了防止频繁通过IO读取磁盘带来的性能开销,毕竟SharedPreferences还是比较常用的,如果实时去磁盘文件进行读取,那么在性能上肯定有不容忽视的影响。
同时,MODE_MULTI_PROCESS的模式也已经被Google弃用,多进程之间的数据共享Google不推荐我们使用SharedPreferences,而是使用例如ContentProvider这种方式。
同时,通过源码我们发现,如果对存储的成功与否的结果并不关心的话,使用apply方法进行提交可以在性能上有一定的优化,因为apply方法是在线程池进行文件的写入,而commit方法则是直接在当前线程进行文件的写入的。