细数 SharedPreferences 的那些槽点 ！
程序员文章站
2022-07-09 20:27:45
前言 最近在处理一个历史遗留项目的时候饱受其害，主要表现为偶发性的 SharedPreferences 配置文件数据错乱，甚至丢失。经过排查发现是多进程的问题。项目中有两个不同进程，且会频繁的读写 SharedPreferences 文件，所以导致了数据错乱和丢失。趁此机会，精读了一遍 Shared ......
前言
最近在处理一个历史遗留项目的时候饱受其害，主要表现为偶发性的 sharedpreferences 配置文件数据错乱，甚至丢失。经过排查发现是多进程的问题。项目中有两个不同进程，且会频繁的读写 sharedpreferences 文件，所以导致了数据错乱和丢失。趁此机会，精读了一遍 sharedpreferences 源码，下面就来说说 sharedpreferences 都有哪些槽点。
源码解析
sharedpreferences 的使用很简单，这里就不再演示了。下面就按 获取 sharedpreference 、getxxx() 获取数据 和 putxxx()存储数据 这三方面来阅读源码。
1. 获取 sharedpreferences
1.1 getdefaultsharedpreferences()
一般我们会通过 preferencemanager 的 getdefaultsharedpreferences() 方法来获取默认的 sharedpreferences 对象，其代码如下所示：
> preferencemanager.java
/**
* 获取默认的 sharedpreferences 对象，文件名为 packagename_preferences , mode 为 mode_private
*/
public static sharedpreferences getdefaultsharedpreferences(context context) {
return context.getsharedpreferences(getdefaultsharedpreferencesname(context),
getdefaultsharedpreferencesmode()); // 见 1.2
}
默认的 sp 文件完整路径为 /data/data/shared_prefs/[packagename]_preferences.xml。mode 默认为 mode_private，其实现在也只用这种模式了，后面的源码解析中也会提到。最后都会调用到 contextimpl 的 getsharedpreferences() 方法。
1.2 getsharedpreferences(string name, int mode)
> contextimpl.java
@override
public sharedpreferences getsharedpreferences(string name, int mode) {
// at least one application in the world actually passes in a null
// name. this happened to work because when we generated the file name
// we would stringify it to "null.xml". nice.
if (mpackageinfo.getapplicationinfo().targetsdkversion <
build.version_codes.kitkat) {
if (name == null) {
name = "null";
}
}
file file;
synchronized (contextimpl.class) {
if (msharedprefspaths == null) {
msharedprefspaths = new arraymap<>();
}
// 先从缓存 msharedprefspaths 中查找 sp 文件是否存在
file = msharedprefspaths.get(name);
if (file == null) { // 如果不存在，新建 sp 文件，文件名为 "name.xml"
file = getsharedpreferencespath(name);
msharedprefspaths.put(name, file);
}
}
return getsharedpreferences(file, mode); // 见 1.3
}
首先这里出现了一个变量 msharedprefspaths，找一下它的定义：
/**
* 文件名为 key，具体文件为 value。存储所有 sp 文件
* 由 contextimpl.class 锁保护
*/
@guardedby("contextimpl.class")
private arraymap<string, file> msharedprefspaths;
msharedprefspaths 是一个 arraymap ，缓存了文件名和 sp 文件的对应关系。首先会根据参数中的文件名 name 查找缓存中是否存在对应的 sp 文件。如果不存在的话，会新建名称为 [name].xml 的文件，并存入缓存 msharedprefspaths 中。最后会调用另一个重载的 getsharedpreferences() 方法，参数是 file 。
1.3 getsharedpreferences(file file, int mode)
> contextimpl.java
@override
public sharedpreferences getsharedpreferences(file file, int mode) {
sharedpreferencesimpl sp;
synchronized (contextimpl.class) {
final arraymap<file, sharedpreferencesimpl> cache = getsharedpreferencescachelocked(); // 见 1.3.1
sp = cache.get(file); // 先从缓存中尝试获取 sp
if (sp == null) { // 如果获取缓存失败
checkmode(mode); // 检查 mode，见 1.3.2
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); // 创建 sharedpreferencesimpl，见 1.4
cache.put(file, sp);
return sp;
}
}
// mode 为 mode_multi_process 时，文件可能被其他进程修改，则重新加载
// 显然这并不足以保证跨进程安全
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;
}
sharedpreferences 只是接口而已，我们要获取的实际上是它的实现类 sharedpreferencesimpl 。通过 getsharedpreferencescachelocked() 方法可以获取已经缓存的 sharedpreferencesimpl 对象和其 sp 文件。
1.3.1 getsharedpreferencescachelocked()
> contextimpl.java
private arraymap<file, sharedpreferencesimpl> getsharedpreferencescachelocked() {
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;
}
ssharedprefscache 是一个嵌套的 arraymap，其定义如下：
private static arraymap<string, arraymap<file, sharedpreferencesimpl>> ssharedprefscache;
以包名为 key ，以一个存储了 sp 文件及其 sharedpreferencesimp 对象的 arraymap 为 value。如果存在直接返回，反之创建一个新的 arraymap 作为值并存入缓存。
1.3.2 checkmode()
> contextimpl.java
private void checkmode(int mode) {
// 从 n 开始，如果使用 mode_world_readable 和 mode_world_writeable，直接抛出异常
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");
}
}
}
从 android n 开始，明确不再支持 mode_world_readable 和 mode_world_writeable，再加上 mode_multi_process 并不能保证线程安全，一般就使用 mode_private 就可以了。
1.4 sharedpreferencesimpl
如果缓存中没有对应的 sharedpreferencesimpl 对象，就得自己创建了。看一下它的构造函数：
sharedpreferencesimpl(file file, int mode) {
mfile = file; // sp 文件
mbackupfile = makebackupfile(file); // 创建备份文件
mmode = mode;
mloaded = false; // 标识 sp 文件是否已经加载到内存
mmap = null; // 存储 sp 文件中的键值对
mthrowable = null;
startloadfromdisk(); // 加载数据，见 1.4.1
}
注意这里的 mmap，它是一个 map<string, object>，存储了 sp 文件中的所有键值对。所以 sharedpreferences 文件的所有数据都是存在于内存中的，既然存在于内存中，就注定它不适合存储大量数据。
1.4.1 startloadfromdisk()
> sharedpreferencesimpl.java
private void startloadfromdisk() {
synchronized (mlock) {
mloaded = false;
}
new thread("sharedpreferencesimpl-load") {
public void run() {
loadfromdisk(); // 异步加载。 见 1.4.2
}
}.start();
}
1.4.2 loadfromdisk()
> sharedpreferencesimpl.java
private void loadfromdisk() {
synchronized (mlock) { // 获取 mlock 锁
if (mloaded) { // 已经加载进内存，直接返回，不再读取文件
return;
}
if (mbackupfile.exists()) { // 如果存在备份文件，直接将备份文件重命名为 sp 文件
mfile.delete();
mbackupfile.renameto(mfile);
}
}
// debugging
if (mfile.exists() && !mfile.canread()) {
log.w(tag, "attempt to read preferences file " + mfile + " without permission");
}
map<string, object> map = null;
structstat stat = null;
throwable thrown = null;
try { // 读取 sp 文件
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;
}
synchronized (mlock) {
mloaded = true;
mthrowable = thrown;
// it's important that we always signal waiters, even if we'll make
// them fail with an exception. the try-finally is pretty wide, but
// better safe than sorry.
try {
if (thrown == null) {
if (map != null) {
mmap = map;
mstattimestamp = stat.st_mtim; // 更新修改时间
mstatsize = stat.st_size; // 更新文件大小
} else {
mmap = new hashmap<>();
}
}
// in case of a thrown exception, we retain the old map. that allows
// any open editors to commit and store updates.
} catch (throwable t) {
mthrowable = t;
} finally {
mlock.notifyall(); // 唤醒处于等待状态的线程
}
}
}
简单捋一下流程：
- 判断是否已经加载进内存
- 判断是否存在遗留的备份文件，如果存在，重命名为 sp 文件
- 读取 sp 文件，并存入内存
- 更新文件信息
- 释放锁，唤醒处于等待状态的线程
loadfromdisk() 是异步执行的，而且是线程安全的，读取过程中持有锁 mlock，看起来设计的都很合理，但是在不合理的使用情况下就会出现问题。
看了这么长的源码，别忘了我们还停留在 getsharedpreferences() 方法，也就是获取 sharedpreferences 的过程中。如果我们在使用过程中，调用 getsharedpreferences() 之后，直接调用 getxxx() 方法来获取数据，恰好 sp 文件数据量又比较大，读取过程比较耗时，getxxx() 方法就会被阻塞。后面看到 getxxx() 方法的源码时，你就会看到它需要等待 sp 文件加载完成，否则就会阻塞。所以在使用过程中，可以提前异步初始化 sharedpreferences 对象，加载 sp 文件进内存，避免发生潜在可能的卡顿。这是 sharedpreferences 的一个槽点，也是我们使用过程中需要注意的。
2. 读取 sp 数据
获取 sp 文件中的数据使用的是 sharedpreferencesimpl 中的七个 getxxx 函数。这七个函数都是一样的逻辑，以 getint() 为例看一下源码：
> sharedpreferencesimpl.java
@override
public int getint(string key, int defvalue) {
synchronized (mlock) {
awaitloadedlocked(); // sp 文件尚未加载完成时，会阻塞在这里，见 2.1
integer v = (integer)mmap.get(key); // 加载完成后直接从内存中读取
return v != null ? v : defvalue;
}
}
一旦 sp 文件加载完成，所有获取数据的操作都是从内存中读取的。这样的确提升了效率，但是很显然将大量的数据直接放在内存是不合适的，所以注定了 sharedpreferences 不适合存储大量数据。
2.1 awaitloadedlocked()
> sharedpreferencesimpl.java
@guardedby("mlock")
private void awaitloadedlocked() {
if (!mloaded) {
// raise an explicit strictmode onreadfromdisk for this
// thread, since the real read will be in a different
// thread and otherwise ignored by strictmode.
blockguard.getthreadpolicy().onreadfromdisk();
}
while (!mloaded) { // sp 文件尚未加载完成时, 等待
try {
mlock.wait();
} catch (interruptedexception unused) {
}
}
if (mthrowable != null) {
throw new illegalstateexception(mthrowable);
}
}
mloaded 初始值为 false，在 loadfromdisk() 方法中读取 sp 文件之后会被置为 true，并调用 mlock.notifyall() 通知等待的线程。
3. 存储 sp 数据
sharedpreferences 存储数据的基本方法如下：
val editor = preferencemanager.getdefaultsharedpreferences(this).edit()
editor.putint("key",1)
editor.commit()/editor.apply()
edit() 方法会返回一个 editor() 对象。editor 和 sharedpreferences 一样，都只是接口，它们的实现类分别是 editorimpl 和 sharedpreferencesimpl。
3.1 edit()
> sharedpreferencesimpl.java
@override
public editor edit() {
synchronized (mlock) {
awaitloadedlocked(); // 等待 sp 文件加载完成
}
return new editorimpl(); // 见 3.2
}
edit() 方法同样也要等待 sp 文件加载完成，再进行 editimpl() 的初始化。每次调用 edit() 方法都会实例化一个新的 editorimpl 对象。所以我们在使用的时候要注意不要每次 put() 都去调用 edit() 方法，在封装 sharedpreferences 工具类的时候可能会犯这个错误。
3.2 editorimpl
> sharedpreferencesimpl.java
public final class editorimpl implements editor {
private final object meditorlock = new object();
@guardedby("meditorlock")
private final map<string, object> mmodified = new hashmap<>(); // 存储要修改的数据
@guardedby("meditorlock")
private boolean mclear = false; // 清除标记
@override
public editor putstring(string key, @nullable string value) {
synchronized (meditorlock) {
mmodified.put(key, value);
return this;
}
}
@override
public editor remove(string key) {
synchronized (meditorlock) {
mmodified.put(key, this);
return this;
}
}
@override
public editor clear() {
synchronized (meditorlock) {
mclear = true;
return this;
}
}
@override
public boolean commit() { } // 见 3.2.1
@override
public boolean apply() { } // 见 3.2.2
有两个成员变量，mmodified 和 mclear。mmodified 是一个 hashmap，存储了所有通过 putxxx() 方法添加的需要添加或者修改的键值对。mclear 是清除标记，在 clear() 方法中会被置为 true。
所有的 putxxx() 方法都只是改变了 mmodified 集合，当调用 commit() 或者 apply() 时才会去修改 sp 文件。下面分别看一下这两个方法。
3.2.1 commit()
> sharedpreferencesimpl.java
@override
public boolean commit() {
long starttime = 0;
if (debug) {
starttime = system.currenttimemillis();
}
// 先将 mmodified 同步到内存
memorycommitresult mcr = committomemory(); // 见 3.2.2
// 再将内存数据同步到文件，见 3.2.3
sharedpreferencesimpl.this.enqueuediskwrite(
mcr, null /* sync write on this thread okay */);
try {
mcr.writtentodisklatch.await(); // 等待写入操作完成
} catch (interruptedexception e) {
return false;
} finally {
if (debug) {
log.d(tag, mfile.getname() + ":" + mcr.memorystategeneration
+ " committed after " + (system.currenttimemillis() - starttime)
+ " ms");
}
}
notifylisteners(mcr); // 通知监听者，回调 onsharedpreferencechangelistener
return mcr.writetodiskresult; // 返回写入操作结果
}
commit() 的大致流程是：
- 首先同步
mmodified到内存中 , committomemory() - 然后同步内存数据到 sp 文件中 ，enqueuediskwrite()
- 等待写入操作完成，并通知监听者
内存同步是 committomemory() 方法，写入文件是 enqueuediskwrite() 方法。来详细看一下这两个方法。
3.2.2 committomemory()
> sharedpreferencesimpl.java
// returns true if any changes were made
private memorycommitresult committomemory() {
long memorystategeneration;
list<string> keysmodified = null;
set<onsharedpreferencechangelistener> listeners = null;
map<string, object> maptowritetodisk;
synchronized (sharedpreferencesimpl.this.mlock) {
// 在 commit() 的写入本地文件过程中，会将 mdiskwritesinflight 置为 1.
// 写入过程尚未完成时，又调用了 committomemory()，直接修改 mmap 可能会影响写入结果
// 所以这里要对 mmap 进行一次深拷贝
if (mdiskwritesinflight > 0) {
mmap = new hashmap<string, object>(mmap);
}
maptowritetodisk = mmap;
mdiskwritesinflight++;
boolean haslisteners = mlisteners.size() > 0;
if (haslisteners) {
keysmodified = new arraylist<string>();
listeners = new hashset<onsharedpreferencechangelistener>(mlisteners.keyset());
}
synchronized (meditorlock) {
boolean changesmade = false;
if (mclear) {
if (!maptowritetodisk.isempty()) {
changesmade = true;
maptowritetodisk.clear();
}
mclear = false;
}
for (map.entry<string, object> e : mmodified.entryset()) {
string k = e.getkey();
object v = e.getvalue();
// "this" is the magic value for a removal mutation. in addition,
// setting a value to "null" for a given key is specified to be
// equivalent to calling remove on that key.
// v == this 和 v == null 都表示删除此 key
if (v == this || v == null) {
if (!maptowritetodisk.containskey(k)) {
continue;
}
maptowritetodisk.remove(k);
} else {
if (maptowritetodisk.containskey(k)) {
object existingvalue = maptowritetodisk.get(k);
if (existingvalue != null && existingvalue.equals(v)) {
continue;
}
}
maptowritetodisk.put(k, v);
}
changesmade = true;
if (haslisteners) {
keysmodified.add(k);
}
}
mmodified.clear();
if (changesmade) {
mcurrentmemorystategeneration++;
}
memorystategeneration = mcurrentmemorystategeneration;
}
}
return new memorycommitresult(memorystategeneration, keysmodified, listeners,
maptowritetodisk);
}
简单说，committomemory() 方法会将所有需要改动的数据 mmodified 和原 sp 文件数据 mmap 进行合并生成一个新的数据集合 maptowritetodisk,从名字也可以看出来，这就是之后要写入文件的数据集。没错，sharedpreferences 的写入都是全量写入。即使你只改动了其中一个配置项，也会重新写入所有数据。针对这一点，我们可以做的优化是，将需要频繁改动的配置项使用单独的 sp 文件进行存储，避免每次都要全量写入。
3.2.3 enqueuediskwrite()
> sharedpreferencesimpl.java
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); // 见 3.2.3.1
}
synchronized (mlock) {
mdiskwritesinflight--;
}
if (postwriterunnable != null) {
postwriterunnable.run();
}
}
};
// typical #commit() path with fewer allocations, doing a write on
// the current thread.
// commit() 直接在当前线程进行写入操作
if (isfromsynccommit) {
boolean wasempty = false;
synchronized (mlock) {
wasempty = mdiskwritesinflight == 1;
}
if (wasempty) {
writetodiskrunnable.run();
return;
}
}
// apply() 方法执行此处，由 queuedwork.queuedworkhandler 处理
queuedwork.queue(writetodiskrunnable, !isfromsynccommit);
}
回头先看一下 commit() 方法中是如何调用 enqueuediskwrite() 方法的：
sharedpreferencesimpl.this.enqueuediskwrite(mcr, null);
第二个参数 postwriterunnable 是 null，所以 isfromsynccommit 为 true，会执行上面的 if 代码块，而不执行 queuedwork.queue()。由此可见，commit() 方法最后的写文件操作是直接在当前调用线程执行的，你在主线程调用该方法，就会直接在主线程进行 io 操作。显然，这是不建议的，可能造成卡顿或者 anr。在实际使用中我们应该尽量使用 apply() 方法来提交数据。当然，apply() 也并不是十全十美的，后面我们会提到。
3.2.3.1 writetofile()
commit() 方法的最后一步了，将 maptowritetodisk 写入 sp 文件。
> sharedpreferencesimpl.java
private void writetofile(memorycommitresult mcr, boolean isfromsynccommit) {
long starttime = 0;
long existstime = 0;
long backupexiststime = 0;
long outputstreamcreatetime = 0;
long writetime = 0;
long fsynctime = 0;
long setpermtime = 0;
long fstattime = 0;
long deletetime = 0;
if (debug) {
starttime = system.currenttimemillis();
}
boolean fileexists = mfile.exists();
if (debug) {
existstime = system.currenttimemillis();
// might not be set, hence init them to a default value
backupexiststime = existstime;
}
// rename the current file so it may be used as a backup during the next read
if (fileexists) {
boolean needswrite = false;
// only need to write if the disk state is older than this commit
// 仅当磁盘状态比当前提交旧时草需要写入文件
if (mdiskstategeneration < mcr.memorystategeneration) {
if (isfromsynccommit) {
needswrite = true;
} else {
synchronized (mlock) {
// no need to persist intermediate states. just wait for the latest state to
// be persisted.
if (mcurrentmemorystategeneration == mcr.memorystategeneration) {
needswrite = true;
}
}
}
}
if (!needswrite) { // 无需写入，直接返回
mcr.setdiskwriteresult(false, true);
return;
}
boolean backupfileexists = mbackupfile.exists(); // 备份文件是否存在
if (debug) {
backupexiststime = system.currenttimemillis();
}
// 如果备份文件不存在，将 mfile 重命名为备份文件，供以后遇到异常时使用
if (!backupfileexists) {
if (!mfile.renameto(mbackupfile)) {
log.e(tag, "couldn't rename file " + mfile
+ " to backup file " + mbackupfile);
mcr.setdiskwriteresult(false, false);
return;
}
} else {
mfile.delete();
}
}
// attempt to write the file, delete the backup and return true as atomically as
// possible. if any exception occurs, delete the new file; next time we will restore
// from the backup.
try {
fileoutputstream str = createfileoutputstream(mfile);
if (debug) {
outputstreamcreatetime = system.currenttimemillis();
}
if (str == null) {
mcr.setdiskwriteresult(false, false);
return;
}
xmlutils.writemapxml(mcr.maptowritetodisk, str); // 全量写入
writetime = system.currenttimemillis();
fileutils.sync(str);
fsynctime = system.currenttimemillis();
str.close();
contextimpl.setfilepermissionsfrommode(mfile.getpath(), mmode, 0);
if (debug) {
setpermtime = system.currenttimemillis();
}
try {
final structstat stat = os.stat(mfile.getpath());
synchronized (mlock) {
mstattimestamp = stat.st_mtim; // 更新文件时间
mstatsize = stat.st_size; // 更新文件大小
}
} catch (errnoexception e) {
// do nothing
}
if (debug) {
fstattime = system.currenttimemillis();
}
// writing was successful, delete the backup file if there is one.
// 写入成功，删除备份文件
mbackupfile.delete();
if (debug) {
deletetime = system.currenttimemillis();
}
mdiskstategeneration = mcr.memorystategeneration;
// 返回写入成功，唤醒等待线程
mcr.setdiskwriteresult(true, true);
if (debug) {
log.d(tag, "write: " + (existstime - starttime) + "/"
+ (backupexiststime - starttime) + "/"
+ (outputstreamcreatetime - starttime) + "/"
+ (writetime - starttime) + "/"
+ (fsynctime - starttime) + "/"
+ (setpermtime - starttime) + "/"
+ (fstattime - starttime) + "/"
+ (deletetime - starttime));
}
long fsyncduration = fsynctime - writetime;
msynctimes.add((int) fsyncduration);
mnumsync++;
if (debug || mnumsync % 1024 == 0 || fsyncduration > max_fsync_duration_millis) {
msynctimes.log(tag, "time required to fsync " + mfile + ": ");
}
return;
} catch (xmlpullparserexception e) {
log.w(tag, "writetofile: got exception:", e);
} catch (ioexception e) {
log.w(tag, "writetofile: got exception:", e);
}
// clean up an unsuccessfully written file
// 清除未成功写入的文件
if (mfile.exists()) {
if (!mfile.delete()) {
log.e(tag, "couldn't clean up partially-written file " + mfile);
}
}
mcr.setdiskwriteresult(false, false); // 返回写入失败
}
流程比较清晰，代码也比较简单，
3.2.4 apply()
> sharedpreferencesimpl.java
@override
public void apply() {
final long starttime = system.currenttimemillis();
// 先将 mmodified 同步到内存
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);
// 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);
}
同样也是先调用 committomemory() 同步到内存，再调用 enqueuediskwrite() 同步到文件。和 commit() 不同的是，enqueuediskwrite() 方法的 runnable 参数不再是 null 了，传进来一个 postwriterunnable 。所以其内部的执行逻辑和 commit() 方法是完全不同的。可以再回到 3.2.3 节看一下，commit() 方法会直接在当前线程执行 writetodiskrunnable()，而 apply() 会由 queuedwork 来处理：
queuedwork.queue(writetodiskrunnable, !isfromsynccommit); // 见 3.2.5
3.2.5 queue()
> queuedwork.java
public static void queue(runnable work, boolean shoulddelay) {
handler handler = gethandler();
synchronized (slock) {
swork.add(work);
if (shoulddelay && scandelay) {
handler.sendemptymessagedelayed(queuedworkhandler.msg_run, delay);
} else {
handler.sendemptymessage(queuedworkhandler.msg_run);
}
}
}
这里的 handler 所在的线程就是执行 runnable 的线程了，看一下 gethandler 源码：
> queuedwork.java
private static handler gethandler() {
synchronized (slock) {
if (shandler == null) {
handlerthread handlerthread = new handlerthread("queued-work-looper",
process.thread_priority_foreground);
handlerthread.start();
shandler = new queuedworkhandler(handlerthread.getlooper());
}
return shandler;
}
}
写 sp 文件的操作会异步执行在一个单独的线程上。
queuedwork 除了执行异步操作之外，还有一个作用。它可以确保当 activity onpause()/onstop() 之后，或者 broadcast onreceive() 之后，异步任务可以执行完成。以 activitythread.java 中 handlepauseactivity() 方法为例：
@override
public void handlestopactivity(ibinder token, boolean show, int configchanges,
pendingtransactionactions pendingactions, boolean finalstaterequest, string reason) {
final activityclientrecord r = mactivities.get(token);
r.activity.mconfigchangeflags |= configchanges;
final stopinfo stopinfo = new stopinfo();
performstopactivityinner(r, stopinfo, show, true /* savestate */, finalstaterequest,
reason);
if (locallogv) slog.v(
tag, "finishing stop of " + r + ": show=" + show
+ " win=" + r.window);
updatevisibility(r, show);
// make sure any pending writes are now committed.
// 可能因等待写入造成卡顿甚至 anr
if (!r.isprehoneycomb()) {
queuedwork.waittofinish();
}
stopinfo.setactivity(r);
stopinfo.setstate(r.state);
stopinfo.setpersistentstate(r.persistentstate);
pendingactions.setstopinfo(stopinfo);
msomeactivitieschanged = true;
}
初衷可能是好的，但是我们都知道在 activity() 的 onpause()/onstop() 中不应该进行耗时任务。如果 sp 数据量很大的话，这里无疑会出现性能问题，可能造成卡顿甚至 anr。
总结
撸完 sharedpreferences 源码，槽点可真不少！
- 不支持跨进程，
mode_multi_process也没用。跨进程频繁读写可能导致数据损坏或丢失。 - 初始化的时候会读取 sp 文件，可能导致后续
getxxx()方法阻塞。建议提前异步初始化 sharedpreferences。 - sp 文件的数据会全部保存在内存中，所以不宜存放大数据。
-
edit()方法每次都会新建一个editorimpl对象。建议一次 edit()，多次 putxxx() 。 - 无论是
commit()还是apply()，针对任何修改都是全量写入。建议针对高频修改的配置项存在子啊单独的 sp 文件。 -
commit()同步保存，有返回值。apply()异步保存，无返回值。按需取用。 -
onpause()、onreceive()等时机会等待异步写操作执行完成，可能造成卡顿或者 anr。
这么多问题，我们是不是不应该使用 sharedpreferences 呢？答案肯定不是的。如果你不需要跨进程，仅仅存储少量的配置项，sharedpreferences 仍然是一个很好的选择。
如果 sharedpreferences 已经满足不了你的需求了，给你推荐 tencent 开源的 mmkv !
文章首发微信公众号：
秉心说， 专注 java 、 android 原创知识分享，leetcode 题解。更多最新原创文章，扫码关注我吧！
上一篇： drf框架接口文档
下一篇： Jenkins基础系统之更换镜像源