SharedPreferences

SharedPreferences是Android中轻量级的数据存储方式，适用于保存简单的数据类型。其内部是以xml结构保存在/data/data/{包名}/shared_prefs文件夹下的。数据以键值对的形式保存，如下：

<map>
<floatname="isFloat"value="1.5" />
<stringname="isString">Android</string>
<intname="isInt"value="1" />
<longname="isLong"value="1000" />
<booleanname="isBoolean"value="true" />
<setname="isStringSet">
<string>element 1</string>
<string>element 2</string>
<string>element 3</string>
</set>
</map>

1.简单使用

// 通过Context获取SharedPreferencesImpl实例SharedPreferencessp = Context.getSharedPreferences("my_sp", Context.MODE_PRIVATE);
// 通过SP获取EditorImpl实例SharedPreferences.Editoredit = sp.edit();
// 存入key为value，值为text的数据。edit.putString("value","test");
// 提交edit.apply(); // 或者edit.commit();// 从SP中读取value对应的值sp.getString("value","");

2.获取SharedPreferences

通过ContextImpl的getSharedPreferences获取

// 缓存了name到文件的映射privateArrayMap<String, File> mSharedPrefsPaths;
@OverridepublicSharedPreferencesgetSharedPreferences(Stringname, intmode) {
// 查找name对应的SP文件Filefile;
synchronized (ContextImpl.class) {
if (mSharedPrefsPaths == null) {
mSharedPrefsPaths = newArrayMap<>();
}
// 根据name从缓存中取出SP文件file = mSharedPrefsPaths.get(name);
if (file == null) {
// 没有在缓存中则根据name创建xml文件file = getSharedPreferencesPath(name);
// 保存name与创建的文件mSharedPrefsPaths.put(name, file);
}
}
// 真正获取SPreturngetSharedPreferences(file, mode);
}
// 调用makeFilename创建xml文件：@OverridepublicFilegetSharedPreferencesPath(Stringname) {
returnmakeFilename(getPreferencesDir(), name + ".xml");
}

mSharedPrefsPaths记录了所有SP文件，以文件名为key，具体文件为value。

@OverridepublicSharedPreferencesgetSharedPreferences(Filefile, intmode) {
SharedPreferencesImplsp;
synchronized (ContextImpl.class) {
// 获取缓存集合ArrayMapfinalArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
// 从缓存中读取SPsp = cache.get(file);
if (sp == null) {
// ...// 实例化SPsp = newSharedPreferencesImpl(file, mode);
// 放入缓存cache.put(file, sp);
returnsp;
}
}
// ...returnsp;
}
// sSharedPrefsCache:以包名为key, 二级key是以SP文件, 以SharedPreferencesImpl为value的嵌套map结构. 这里需要sSharedPrefsCache是静态类成员变量, 每个进程是保存唯一一份,privatestaticArrayMap<String, ArrayMap<File, SharedPreferencesImpl>> sSharedPrefsCache;
privateArrayMap<File, SharedPreferencesImpl> getSharedPreferencesCacheLocked() {
if (sSharedPrefsCache == null) {
sSharedPrefsCache = newArrayMap<>();
}
finalStringpackageName = getPackageName();
ArrayMap<File, SharedPreferencesImpl> packagePrefs = sSharedPrefsCache.get(packageName);
if (packagePrefs == null) {
packagePrefs = newArrayMap<>();
sSharedPrefsCache.put(packageName, packagePrefs);
}
returnpackagePrefs;
}

可以看到ContextImpl的getSharedPreferences最终获取到的是SharedPreferencesImpl实例对象。SharedPreferencesImpl的构造方法如下：

SharedPreferencesImpl(Filefile, intmode) {
mFile = file;
// 创建备份文件mBackupFile = makeBackupFile(file);
mMode = mode;
mLoaded = false;
mMap = null;
mThrowable = null;
// 开启从磁盘加载startLoadFromDisk();
}

@UnsupportedAppUsageprivatevoidstartLoadFromDisk() {
synchronized (mLock) {
mLoaded = false;
}
// 开启子线程从磁盘加载数据newThread("SharedPreferencesImpl-load") {
publicvoidrun() {
loadFromDisk();
}
}.start();
}

privatevoidloadFromDisk() {
// ...Map<String, Object> map = null;
StructStatstat = null;
Throwablethrown = null;
try {
stat = Os.stat(mFile.getPath());
if (mFile.canRead()) {
BufferedInputStreamstr = null;
try {
// 读取xml文件流str = newBufferedInputStream(
newFileInputStream(mFile), 16 * 1024);
// 将xml文件解析成map集合map = (Map<String, Object>) XmlUtils.readMapXml(str);
} catch (Exceptione) {
Log.w(TAG, "Cannot read " + mFile.getAbsolutePath(), e);
} finally {
IoUtils.closeQuietly(str);
}
}
} catch (Throwablet) {
thrown = t;
}
synchronized (mLock) {
mLoaded = true;
mThrowable = thrown;
try {
if (thrown == null) {
if (map != null) {
// 赋值给mMapmMap = map;
mStatTimestamp = stat.st_mtim;
mStatSize = stat.st_size;
} else {
mMap = newHashMap<>();
}
}
// In case of a thrown exception, we retain the old map. That allows// any open editors to commit and store updates.
} catch (Throwablet) {
mThrowable = t;
} finally {
// 加载结束后唤醒所有线程mLock.notifyAll();
}
}
}

SharedPreferencesImpl的构造方法中会从磁盘上读取xml文件，并将该文件解析成一个Map集合，并赋值mMap这个成员变量。

2.从SP中读取数据

以getString为例：

@Override@NullablepublicStringgetString(Stringkey, @NullableStringdefValue) {
synchronized (mLock) {
// 这里会调用awaitLoadedLocked方法看是否已加载了xml文件// 如果没加载则阻塞主线程并加载xml文件awaitLoadedLocked();
// 加载完成后才会从内从中读取key对应的valueStringv = (String)mMap.get(key);
returnv != null ? v : defValue;
}
}

getString中使用synchronized对代码块进行了加锁，并且首先会调用awaitLoadedLocked方法去加载xml文件。

@GuardedBy("mLock")
privatevoidawaitLoadedLocked() {
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) {
try {
mLock.wait();
} catch (InterruptedExceptionunused) {
}
}
if (mThrowable != null) {
thrownewIllegalStateException(mThrowable);
}
}

可以看到awaitLoadedLocked方法中会先判断是否已经从磁盘加载了xml文件，如果没有则会通过BlockGuard开启一个线程从磁盘中读取文件。没太搞明白BlockGuard是什么东西...它会通过某种方式调用了loadFromDisk方法？然后在loadFromDisk中加载文件完成后将Loaded置为true，并且 mLock.notifyAll()来唤起线程？不管怎样在while之前的代码是一个耗时操作，在mLoaded为false的时候会一直阻塞主线程，如果xml文件中存储数据过多会长时间阻塞主线程，造成一定性能问题。

3.Editor

接着调用了SharedPreferencesImpl的edit方法来获取Editor的实例，代码如下：

// SharedPreferencesImpl@OverridepublicEditoredit() {
synchronized (mLock) {
// 这里再次出现awaitLoadedLocked方法awaitLoadedLocked();
}
returnnewEditorImpl();
}

edit方法中也会先通过awaitLoadedLocked方法查看是否已经加载xml文件，如果没有加载则阻塞线程加载xml，加载成功后则会实例化一个EditorImpl实例对象。

publicfinalclassEditorImplimplementsEditor {
privatefinalObjectmEditorLock = newObject();
@GuardedBy("mEditorLock")
privatefinalMap<String, Object> mModified = newHashMap<>();
@GuardedBy("mEditorLock")
privatebooleanmClear = false;
@OverridepublicEditorputString(Stringkey, @NullableStringvalue) {
synchronized (mEditorLock) {
mModified.put(key, value);
returnthis;
}
}
//... 省略了各种put方法@OverridepublicEditorremove(Stringkey) {
synchronized (mEditorLock) {
mModified.put(key, this);
returnthis;
}
}
@OverridepublicEditorclear() {
synchronized (mEditorLock) {
mClear = true;
returnthis;
}
}
@Overridepublicvoidapply() {
finallongstartTime = System.currentTimeMillis();
// 提交到内存finalMemoryCommitResultmcr = commitToMemory();
finalRunnableawaitCommit = newRunnable() {
@Overridepublicvoidrun() {
try {
// 写入磁盘文件mcr.writtenToDiskLatch.await();
} catch (InterruptedExceptionignored) {
}
}
};
QueuedWork.addFinisher(awaitCommit);
RunnablepostWriteRunnable = newRunnable() {
@Overridepublicvoidrun() {
awaitCommit.run();
QueuedWork.removeFinisher(awaitCommit);
}
};
SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
notifyListeners(mcr);
}
@Overridepublicbooleancommit() {
longstartTime = 0;
// 提交到内存MemoryCommitResultmcr = commitToMemory();
// 写入磁盘SharedPreferencesImpl.this.enqueueDiskWrite(mcr, null);
try {
mcr.writtenToDiskLatch.await();
} // ...notifyListeners(mcr);
// 返回文件操作结果returnmcr.writeToDiskResult;
}
}

可以看到，调用putXXX方法时仅仅是将数据存入了mModified的map集合中，只有调用apply或者commit方法的时候才会去commitToMemory和写入磁盘。

4. commit与apply

commit方法

@Overridepublicbooleancommit() {
longstartTime = 0;
// 将数据更新到内存MemoryCommitResultmcr = commitToMemory();
// 写入磁盘SharedPreferencesImpl.this.enqueueDiskWrite(mcr, null);
try {
mcr.writtenToDiskLatch.await();
} // ...notifyListeners(mcr);
// 返回文件操作结果returnmcr.writeToDiskResult;
}

privatevoidenqueueDiskWrite(finalMemoryCommitResultmcr,
finalRunnablepostWriteRunnable) {
finalbooleanisFromSyncCommit = (postWriteRunnable == null);
finalRunnablewriteToDiskRunnable = newRunnable() {
@Overridepublicvoidrun() {
synchronized (mWritingToDiskLock) {
// 将数据写入文件writeToFile(mcr, isFromSyncCommit);
}
synchronized (mLock) {
mDiskWritesInFlight--;
}
if (postWriteRunnable != null) {
postWriteRunnable.run();
}
}
};
if (isFromSyncCommit) {
// commit方法会进入此处booleanwasEmpty = false;
synchronized (mLock) {
//commitToMemory过程会加1,则wasEmpty=truewasEmpty = mDiskWritesInFlight == 1;
}
if (wasEmpty) {
writeToDiskRunnable.run();
return;
}
}
QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);
}

每次commit是把全部数据更新到文件, 所以每个文件的数据量必须保证足够精简.

apply方法

publicvoidapply() {
finallongstartTime = System.currentTimeMillis();
// 更新到内存finalMemoryCommitResultmcr = commitToMemory();
finalRunnableawaitCommit = newRunnable() {
@Overridepublicvoidrun() {
try {
// 进入等待状态mcr.writtenToDiskLatch.await();
}
// ...
}
};
QueuedWork.addFinisher(awaitCommit);
RunnablepostWriteRunnable = newRunnable() {
@Overridepublicvoidrun() {
awaitCommit.run();
QueuedWork.removeFinisher(awaitCommit);
}
};
// 开始写入操作SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
notifyListeners(mcr);
}

privatevoidenqueueDiskWrite(finalMemoryCommitResultmcr,
finalRunnablepostWriteRunnable) {
finalbooleanisFromSyncCommit = (postWriteRunnable == null);
finalRunnablewriteToDiskRunnable = newRunnable() {
@Overridepublicvoidrun() {
synchronized (mWritingToDiskLock) {
//执行文件写入操作writeToFile(mcr, isFromSyncCommit);
}
synchronized (mLock) {
mDiskWritesInFlight--;
}
if (postWriteRunnable != null) {
postWriteRunnable.run();
}
}
};
if (isFromSyncCommit) {
booleanwasEmpty = false;
synchronized (mLock) {
wasEmpty = mDiskWritesInFlight == 1;
}
if (wasEmpty) {
writeToDiskRunnable.run();
return;
}
}
// 往系统的队列中发送任务，然后在工作线程中执行任务QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);
}

enqueueDiskWrite 方法中首先判断的postWriteRunnable 是否等于null，如果等于空了，就在当前调用的地方执行写入操作，如果不是就往QueuedWork 队列中发送任务.

在apply方法中调用enqueueDiskWrite方法的时候最后一个参数是不等于空的，也就是说我们要执行一个异步任务，最终这异步任务的执行是在QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit)方法中

QueuedWork

QueuedWork就是android系统提供的一个执行异步任务的工具类，内部的实现逻辑的就是创建一个HandlerThread作为工作线程，然后QueuedWorkHandler和这个HandlerThread进行管理，每当有任务添加进来就在这个异步线程中执行，这个异步线程的名字queued-work-looper

publicclassQueuedWork {
// 创建handle的过程privatestaticHandlergetHandler() {
synchronized (sLock) {
if (sHandler == null) {
HandlerThreadhandlerThread = newHandlerThread("queued-work-looper",
Process.THREAD_PRIORITY_FOREGROUND);
handlerThread.start();
sHandler = newQueuedWorkHandler(handlerThread.getLooper());
}
returnsHandler;
}
}
publicstaticvoidaddFinisher(Runnablefinisher) {
synchronized (sLock) {
sFinishers.add(finisher);
}
}
publicstaticvoidremoveFinisher(Runnablefinisher) {
synchronized (sLock) {
sFinishers.remove(finisher);
}
}
publicstaticvoidwaitToFinish() {
// ... 省略，见下文
}
// 首先往sWork 添加一个任务，sWork是一个LinkedList，这个队列中数据最终在// queued-work-looper 线程中依次得到执行@UnsupportedAppUsagepublicstaticvoidqueue(Runnablework, booleanshouldDelay) {
Handlerhandler = getHandler();
synchronized (sLock) {
sWork.add(work);
if (shouldDelay && sCanDelay) {
handler.sendEmptyMessageDelayed(QueuedWorkHandler.MSG_RUN, DELAY);
} else {
handler.sendEmptyMessage(QueuedWorkHandler.MSG_RUN);
}
}
}
privatestaticvoidprocessPendingWork() {
longstartTime = 0;
if (DEBUG) {
startTime = System.currentTimeMillis();
}
synchronized (sProcessingWork) {
LinkedList<Runnable> work;
synchronized (sLock) {
work = (LinkedList<Runnable>) sWork.clone();
sWork.clear();
// Remove all msg-s as all work will be processed nowgetHandler().removeMessages(QueuedWorkHandler.MSG_RUN);
}
if (work.size() > 0) {
for (Runnablew
: work) {
w.run();
}
}
}
}
privatestaticclassQueuedWorkHandlerextendsHandler {
staticfinalintMSG_RUN = 1;
QueuedWorkHandler(Looperlooper) {
super(looper);
}
publicvoidhandleMessage(Messagemsg) {
if (msg.what == MSG_RUN) {
processPendingWork();
}
}
}
}

apply方法为什么会引起ANR？

调用 apply 方法时候会向 QueuedWork 中加入一个 Runnable，代码如下：

publicvoidapply() {
finallongstartTime = System.currentTimeMillis();
// 提交到内存finalMemoryCommitResultmcr = commitToMemory();
finalRunnableawaitCommit = newRunnable() {
@Overridepublicvoidrun() {
try {
// 等待写入磁盘文件mcr.writtenToDiskLatch.await();
} catch (InterruptedExceptionignored) {
}
}
};
QueuedWork.addFinisher(awaitCommit);
// ...
}

awaitCommit 这个 Runnable 中会调用 mcr.writtenToDiskLatch.await() 。writtenToDiskLatch是一个 CountDownLatch对象，它初始化时有一个计数值，调用 await() 方法后会阻塞当前线程，直到这个门闩的计数值通过 countDown()方法减到 0。也就是这个 Runnable 执行的时候，如果没有完成磁盘写入，则会一直阻塞调用 apply 方法的线程。

当 ActvityThread 执行了 handleStopActivity 或者 handleServiceArgs 或者 handlePauseActivity 等方法的时候都会调用QueuedWork.waitToFinish() 方法,而此方法中会在异步任务执行完成前一直阻塞住主线程，所以卡顿问题就产生了

publicstaticvoidwaitToFinish() {
longstartTime = System.currentTimeMillis();
booleanhadMessages = false;
Handlerhandler = getHandler();
synchronized (sLock) {
if (handler.hasMessages(QueuedWorkHandler.MSG_RUN)) {
handler.removeMessages(QueuedWorkHandler.MSG_RUN);
if (DEBUG) {
hadMessages = true;
Log.d(LOG_TAG, "waiting");
}
}
sCanDelay = false;
}
StrictMode.ThreadPolicyoldPolicy = StrictMode.allowThreadDiskWrites();
try {
processPendingWork();
} finally {
StrictMode.setThreadPolicy(oldPolicy);
}
try {
while (true) {
Runnablefinisher;
synchronized (sLock) {
// 关键点，读取sFinishers中的数据finisher = sFinishers.poll();
}
if (finisher == null) {
break;
}
// 执行run方法finisher.run();
}
} finally {
sCanDelay = true;
}
synchronized (sLock) {
longwaitTime = System.currentTimeMillis() - startTime;
if (waitTime > 0 || hadMessages) {
mWaitTimes.add(Long.valueOf(waitTime).intValue());
mNumWaits++;
}
}
}

会从sFinishers队列中取出数据然后执行run方法如果 apply中的写入代码不执行完，主线程就一直卡住了，也就出现了我们上面的问题

面试题：SharedPreferences 为什么会导致 ANR？

SharedPreferences 导致 ANR（应用无响应）的核心原因与线程阻塞和磁盘 I/O 操作相关，具体表现为以下两点：

1. 主线程等待磁盘写入完成

• commit() 直接在主线程执行磁盘写入，若数据量大或磁盘性能差，会直接阻塞主线程，引发 ANR
• apply() 方法的异步写入导致 ANR。虽然 apply() 是异步的，但它会将写入任务加入 QueuedWork 队列，由系统在合适的时机（如 Activity/Service 生命周期切换时）执行。若此时主线程调用 handleStopActivity 等方法，会触发 QueuedWork.waitToFinish()，等待所有异步写入完成。若写入任务耗时（如大文件或频繁操作），主线程会被阻塞，导致 ANR。

2. 初始化时的数据加载阻塞

SharedPreferences 首次加载时需从磁盘解析 XML 文件到内存，若文件过大（如存储大量键值对），子线程的加载过程可能耗时较长，导致后续 getXxx() 方法调用时主线程阻塞

优化建议

• 避免在主线程调用 commit()，优先使用 apply()；
• 减少单个 SharedPreferences 文件的数据量，拆分存储为多个小文件；
• 使用 DataStore 替换 SharedPreferences ；
• 对于高频读写场景，考虑使用更高效的数据存储方案（如 Room 数据库）；

参考：https://www.jianshu.com/p/40e42da910e2