前言
想要实现简单数据的持久化，我们首先会想到的方法肯定是SharedPreferences，有没有思考过这个我们使用了很久的类有什么缺点。
getSharedPreferences的实现是在ContextImpl里面。
源码分析：
getSharedPreferences(packageName, MODE_PRIVATE) => getSharedPreferencesPath(name) =>getSharedPreferences(file, mode)
其实getSharedPreferences的源码很简单，通过getSharedPreferencesPath返回一个File,由源码可知,SharedPreferences内部存储使用的是xml文件。
public File getSharedPreferencesPath(String name) {
return makeFilename(getPreferencesDir(), name + ".xml");
}
public SharedPreferences getSharedPreferences(File file, int mode) {
SharedPreferencesImpl sp;
synchronized (ContextImpl.class) {
final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
sp = cache.get(file);
if (sp == null) {
checkMode(mode);
if (getApplicationInfo().targetSdkVersion >= android.os.Build.VERSION_CODES.O) {
if (isCredentialProtectedStorage()
&& !getSystemService(UserManager.class)
.isUserUnlockingOrUnlocked(UserHandle.myUserId())) {
throw new IllegalStateException("SharedPreferences in credential encrypted "
+ "storage are not available until after user is unlocked");
}
}
sp = new SharedPreferencesImpl(file, mode);
cache.put(file, sp);
return sp;
}
}
if ((mode & Context.MODE_MULTI_PROCESS) != 0 ||
getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) {
// If somebody else (some other process) changed the prefs
// file behind our back, we reload it. This has been the
// historical (if undocumented) behavior.
sp.startReloadIfChangedUnexpectedly();
}
return sp;
}
我们根据文件首先去缓存(ArrayMap)里面找，如果没有找到，那么就创建SharedPreferencesImpl对象。
在SharedPreferencesImpl的构造方法中，会调用startLoadFromDisk()方法。然后通过BufferedInputStream去操作文件。
private void startLoadFromDisk() {
synchronized (mLock) {
mLoaded = false;
}
new Thread("SharedPreferencesImpl-load") {
public void run() {
loadFromDisk();
}
}.start();
}
private void loadFromDisk() {
...
Map<String, Object> map = null;
StructStat stat = null;
Throwable thrown = null;
try {
stat = Os.stat(mFile.getPath());
if (mFile.canRead()) {
BufferedInputStream str = null;
try {
str = new BufferedInputStream(
new FileInputStream(mFile), 16 * 1024);
map = (Map<String, Object>) XmlUtils.readMapXml(str);
} catch (Exception e) {
Log.w(TAG, "Cannot read " + mFile.getAbsolutePath(), e);
} finally {
IoUtils.closeQuietly(str);
}
}
} catch (ErrnoException e) {
// An errno exception means the stat failed. Treat as empty/non-existing by
// ignoring.
} catch (Throwable t) {
thrown = t;
}
...
}
接下来我们分析SharedPreferences的存储数据的源码。
我们以getString方法为例，其实就是从map中取出对应的值。这个map的值就是在loadFromDisk()方法中通过读取file得到的。当然如果是空的话就会创建一个HashMap。
public String getString(String key, @Nullable String defValue) {
synchronized (mLock) {
awaitLoadedLocked();
String v = (String)mMap.get(key);
return v != null ? v : defValue;
}
}
下面我们分析put的流程。
mEditor = mSharedPreferences.edit()
mEditor.putInt(random.nextInt().toString(), random.nextInt()).commit()
public Editor edit() {
synchronized (mLock) {
awaitLoadedLocked();
}
return new EditorImpl();
}
public Editor putInt(String key, int value) {
synchronized (mEditorLock) {
mModified.put(key, value);
return this;
}
}
public boolean commit() {
long startTime = 0;
if (DEBUG) {
startTime = System.currentTimeMillis();
}
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;
}
public void apply() {
final long startTime = System.currentTimeMillis();
final MemoryCommitResult mcr = commitToMemory();
final Runnable awaitCommit = new Runnable() {
@Override
public void run() {
try {
mcr.writtenToDiskLatch.await();
} catch (InterruptedException ignored) {
}
if (DEBUG && mcr.wasWritten) {
Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration
+ " applied after " + (System.currentTimeMillis() - startTime)
+ " ms");
}
}
};
QueuedWork.addFinisher(awaitCommit);
Runnable postWriteRunnable = new Runnable() {
@Override
public void run() {
awaitCommit.run();
QueuedWork.removeFinisher(awaitCommit);
}
};
SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
notifyListeners(mcr);
}
private void enqueueDiskWrite(final MemoryCommitResult mcr,
final Runnable postWriteRunnable) {
final boolean isFromSyncCommit = (postWriteRunnable == null);
final Runnable writeToDiskRunnable = new Runnable() {
@Override
public void run() {
synchronized (mWritingToDiskLock) {
writeToFile(mcr, isFromSyncCommit);
}
synchronized (mLock) {
mDiskWritesInFlight--;
}
if (postWriteRunnable != null) {
postWriteRunnable.run();
}
}
};
if (isFromSyncCommit) {
boolean wasEmpty = false;
synchronized (mLock) {
wasEmpty = mDiskWritesInFlight == 1;
}
if (wasEmpty) {
writeToDiskRunnable.run();
return;
}
}
QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);
}
edit()方法会创建一个EditorImpl对象，所以我们不应该在循环中调用edit()方法。
EditorImpl是SharedPreferencesImpl中的一个内部类。putInt()方法实际上就是将值存储到EditorImpl中的HashMap中。
最后调用commit()方法进行提交。这里我们注意commitToMemory()和enqueueDiskWrite(mcr, null )这两个方法。源码我就不贴了，有兴趣的可以自己去看看。
commitToMemory()方法作用是将需要写入文件的数据存储到一个map中即mapToWriteToDisk。
enqueueDiskWrite()方法会新建一个线程调用writeToFile()方法将上一步中的map数据通过FileOutputStream写入到xml文件中。
apply()方法我们稍后分析。
apply()是否会造成ANR？
答案是肯定的，我们都知道apply()方法采用的是异步，使用线程进行提交，那么为什么会造成ANR。
在apply()方法中我们会新建一个任务进行数据的保存，然后调用 QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit)加入队列。
我们都知道创建Activity时会在ActivityThread中调用handlePauseActivity方法。
在handlePauseActivity()方法中有一个QueuedWork.waitToFinish()等待队列完成。所以，当任务所需时间过长时，这时候我们跳转Activity的时候，依旧会造成ANR。
