一. 概述
SharedPreferences(簡稱SP)是Android中很常用的數(shù)據(jù)存儲方式，SP采用key-value（鍵值對）形式, 主要用于輕量級的數(shù)據(jù)存儲, 尤其適合保存應用的配置參數(shù), 但不建議使用SP 來存儲大規(guī)模的數(shù)據(jù), 可能會降低性能.
SP采用xml文件格式來保存數(shù)據(jù), 該文件所在目錄位于/data/data//shared_prefs/
1.1 使用示例
SharedPreferences sharedPreferences = getSharedPreferences("gityuan", Context.MODE_PRIVATE);
Editor editor = sharedPreferences.edit();
editor.putString("blog", "www.gityuan.com");
editor.putInt("years", 3);
editor.commit();
生成的gityuan.xml文件內容如下：
<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
<string name="blog">"www.gityuan.com</string>
<int name="years" value="3" />
</map>
1.2 架構圖
shared_preference.jpg
- SharedPreferences與Editor只是兩個接口.
- SharedPreferencesImpl和EditorImpl分別實現(xiàn)了對應接口.
另外, ContextImpl記錄著SharedPreferences的重要數(shù)據(jù), 如下:
- sSharedPrefsCache:以包名為key, 二級key是以SP文件, 以SharedPreferencesImpl為value的嵌套map結構. 這里需要sSharedPrefsCache是靜態(tài)類成員變量, 每個進程是保存唯一一份, 且由ContextImpl.class鎖保護.
- mSharedPrefsPaths:記錄所有的SP文件, 以文件名為key, 具體文件為value的map結構;
- mPreferencesDir:是指SP所在目錄, 是指/data/data//shared_prefs/
shared_preferences_arch.jpg
圖解:
- putxxx()操作: 把數(shù)據(jù)寫入到EditorImpl.mModified;
- apply()或者commit()操作:
- 先調用commitToMemory(), 將數(shù)據(jù)同步到SharedPreferencesImpl的mMap, 并保存到MemoryCommitResult的mapToWriteToDisk,
- 再調用enqueueDiskWrite(), 寫入到磁盤文件; 先之前把原有數(shù)據(jù)保存到.bak為后綴的文件,用于在寫磁盤的過程出現(xiàn)任何異?？苫謴蛿?shù)據(jù);
- getxxx()操作: 從SharedPreferencesImpl.mMap讀取數(shù)據(jù).
二. SharedPreferences
2.1 獲取方式
2.1.1 getPreferences
[-> Activity.java]
public SharedPreferences getPreferences(int mode) {
//[見下文]
return getSharedPreferences(getLocalClassName(), mode);
}
Activity.getPreferences(mode): 以當前Activity的類名作為SP的文件名. 即xxxActivity.xml.
2.1.2 getDefaultSharedPreferences
[-> PreferenceManager.java]
public static SharedPreferences getDefaultSharedPreferences(Context context) {
//[見下文]
return context.getSharedPreferences(getDefaultSharedPreferencesName(context),
getDefaultSharedPreferencesMode());
}
PreferenceManager.getDefaultSharedPreferences(Context): 以包名加上_preferences作為文件名, 以MODE_PRIVATE模式創(chuàng)建SP文件. 即packgeName_preferences.xml.
2.1.3 getSharedPreferences
當然也可以直接調用Context.getSharedPreferences(name, mode), 以上所有的方法最終都是調用到如下方法:
[-> ContextImpl.java]
class ContextImpl extends Context {
private ArrayMap<String, File> mSharedPrefsPaths;
public SharedPreferences getSharedPreferences(String name, int mode) {
File file;
synchronized (ContextImpl.class) {
if (mSharedPrefsPaths == null) {
mSharedPrefsPaths = new ArrayMap<>();
}
//先從mSharedPrefsPaths查詢是否存在相應文件
file = mSharedPrefsPaths.get(name);
if (file == null) {
//如果文件不存在, 則創(chuàng)建新的文件 [見小節(jié)2.1.4]
file = getSharedPreferencesPath(name);
mSharedPrefsPaths.put(name, file);
}
}
//[見小節(jié)2.2]
return getSharedPreferences(file, mode);
}
}
2.1.4 getSharedPreferencesPath
[-> ContextImpl.java]
public File getSharedPreferencesPath(String name) {
return makeFilename(getPreferencesDir(), name + ".xml");
}
private File getPreferencesDir() {
synchronized (mSync) {
if (mPreferencesDir == null) {
//創(chuàng)建目錄/data/data/package name/shared_prefs/
mPreferencesDir = new File(getDataDir(), "shared_prefs");
}
return ensurePrivateDirExists(mPreferencesDir);
}
}
流程說明:
- 先從mSharedPrefsPaths查詢是否存在相應文件;
- 如果文件不存在, 則創(chuàng)建新的xml文件; 如果目錄也不存在, 則先創(chuàng)建目錄創(chuàng)建目錄/data/data/package name/shared_prefs/
- 其中mSharedPrefsPaths用于記錄所有的SP文件, 是以文件名為key的Map數(shù)據(jù)結構.
2.2 getSharedPreferences
[-> ContextImpl.java]
public SharedPreferences getSharedPreferences(File file, int mode) {
checkMode(mode); //[見小節(jié)2.2.1]
SharedPreferencesImpl sp;
synchronized (ContextImpl.class) {
//[見小節(jié)2.2.2]
final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
sp = cache.get(file);
if (sp == null) {
//創(chuàng)建SharedPreferencesImpl[見小節(jié)2.3]
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) {
sp.startReloadIfChangedUnexpectedly();
}
return sp;
}
2.2.1 checkMode
[-> ContextImpl.java]
private void checkMode(int mode) {
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開始, 創(chuàng)建的SP文件模式, 不允許MODE_WORLD_READABLE和MODE_WORLD_WRITEABLE模塊, 否則會直接拋出異常SecurityException. 另外, 順帶說一下MODE_MULTI_PROCESS這種多進程的方式也是Google不推薦的方式, 后續(xù)同樣會不再支持, 強烈建議App不用使用該方式來實現(xiàn)多個進程實現(xiàn) 同一個SP文件.
當設置MODE_MULTI_PROCESS模式, 則每次getSharedPreferences過程, 會檢查SP文件上次修改時間和文件大小, 一旦所有修改則會重新從磁盤加載文件.
2.2.2 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;
}
2.3 SharedPreferencesImpl初始化
[-> SharedPreferencesImpl.java]
SharedPreferencesImpl(File file, int mode) {
mFile = file;
//創(chuàng)建為.bak為后綴的備份文件
mBackupFile = makeBackupFile(file);
mMode = mode;
mLoaded = false;
mMap = null;
startLoadFromDisk(); //[見小節(jié)2.3.1]
}
同名的.bak備份文件用于發(fā)生異常時, 可通過備份文件來恢復數(shù)據(jù).
2.3.1 startLoadFromDisk
[-> SharedPreferencesImpl.java]
private void startLoadFromDisk() {
synchronized (this) {
mLoaded = false;
}
new Thread("SharedPreferencesImpl-load") {
public void run() {
loadFromDisk(); //[見小節(jié)2.3.2]
}
}.start();
}
mLoaded用于標記SP文件已加載到內存. 創(chuàng)建線程去實現(xiàn)從磁盤加載sp文件的工作.
2.3.2 loadFromDisk
[-> SharedPreferencesImpl.java]
private void loadFromDisk() {
synchronized (SharedPreferencesImpl.this) {
if (mLoaded) {
return;
}
if (mBackupFile.exists()) {
mFile.delete();
mBackupFile.renameTo(mFile);
}
}
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);
map = XmlUtils.readMapXml(str);
} catch (XmlPullParserException | IOException e) {
...
} finally {
IoUtils.closeQuietly(str);
}
}
} catch (ErrnoException e) {
...
}
synchronized (SharedPreferencesImpl.this) {
mLoaded = true;
if (map != null) {
mMap = map; //從文件讀取的信息保存到mMap
mStatTimestamp = stat.st_mtime; //更新修改時間
mStatSize = stat.st_size; //更新文件大小
} else {
mMap = new HashMap<>();
}
notifyAll(); //喚醒處于等待狀態(tài)的線程
}
}
整個獲取SharedPreferences簡單總結:
- 首次使用則創(chuàng)建相應xml文件;
- 異步加載文件內容到內存; 此時執(zhí)行getXXX()和setxxx()以及edit()方法都是阻塞等待的, 直到文件數(shù)據(jù)全部加載到內存;
- 一旦完全加載到內存, 后續(xù)的getXXX()則是直接訪問內存.
2.4 查詢數(shù)據(jù)
2.4.1 getString
[-> SharedPreferencesImpl.java]
public String getString(String key, @Nullable String defValue) {
synchronized (this) {
//檢查是否加載完成[見小節(jié)2.4.2]
awaitLoadedLocked();
String v = (String)mMap.get(key);
return v != null ? v : defValue;
}
}
- 當loadFromDisk沒有執(zhí)行完成, 則會阻塞查詢操作;
- 當數(shù)據(jù)加載完成, 則直接從mMap來查詢相應數(shù)據(jù);
2.4.2 awaitLoadedLocked
[-> SharedPreferencesImpl.java]
private void awaitLoadedLocked() {
if (!mLoaded) {
BlockGuard.getThreadPolicy().onReadFromDisk();
}
while (!mLoaded) {
try {
wait(); //當沒有加載完成,則進入等待狀態(tài)
} catch (InterruptedException unused) {
}
}
}
三. Editor
3.1 edit
[-> SharedPreferencesImpl.java]
public Editor edit() {
synchronized (this) {
awaitLoadedLocked(); //[見小節(jié)2.4.2]
}
return new EditorImpl(); //創(chuàng)建EditorImpl
}
該過程同樣要等待awaitLoadedLocked完成, 然后創(chuàng)建EditorImpl對象. 而EditorImpl作為SharedPreferencesImpl的內部類,其繼承于Editor類.
3.2 EditorImpl
[-> SharedPreferencesImpl.java:: EditorImpl]
public Editor edit() {
synchronized (this) {
awaitLoadedLocked(); //[見小節(jié)2.4.2]
}
return new EditorImpl(); //創(chuàng)建EditorImpl
}
該過程同樣要等待awaitLoadedLocked完成, 然后創(chuàng)建EditorImpl對象. 而EditorImpl作為SharedPreferencesImpl的內部類,其繼承于Editor類.
3.2 EditorImpl
[-> SharedPreferencesImpl.java:: EditorImpl]
public final class EditorImpl implements Editor {
private final Map<String, Object> mModified = Maps.newHashMap();
private boolean mClear = false;
//插入數(shù)據(jù)
public Editor putString(String key, @Nullable String value) {
synchronized (this) {
//插入數(shù)據(jù), 先暫存到mModified對象
mModified.put(key, value);
return this;
}
}
//移除數(shù)據(jù)
public Editor remove(String key) {
synchronized (this) {
mModified.put(key, this);
return this;
}
}
//清空全部數(shù)據(jù)
public Editor clear() {
synchronized (this) {
mClear = true;
return this;
}
}
}
從這里可以看出, 這些數(shù)據(jù)修改操作僅僅是修改mModified和mClear. 直到數(shù)據(jù)提交commit或許apply過程, 才會真正的把數(shù)據(jù)更新到SharedPreferencesImpl(簡稱SPI). 比如設置mClear=true則會情況SPI的mMap數(shù)據(jù).
四. 數(shù)據(jù)提交
4.1 commit
[-> SharedPreferencesImpl.java:: EditorImpl]
public boolean commit() {
//將數(shù)據(jù)更新到內存[見小節(jié)4.2]
MemoryCommitResult mcr = commitToMemory();
//將內存數(shù)據(jù)同步到文件[見小節(jié)4.3]
SharedPreferencesImpl.this.enqueueDiskWrite(mcr, null);
try {
//進入等待狀態(tài), 直到寫入文件的操作完成
mcr.writtenToDiskLatch.await();
} catch (InterruptedException e) {
return false;
}
//通知監(jiān)聽則, 并在主線程回調onSharedPreferenceChanged()方法
notifyListeners(mcr);
// 返回文件操作的結果數(shù)據(jù)
return mcr.writeToDiskResult;
}
4.2 commitToMemory
[-> SharedPreferencesImpl.java:: EditorImpl]
private MemoryCommitResult commitToMemory() {
MemoryCommitResult mcr = new MemoryCommitResult();
synchronized (SharedPreferencesImpl.this) {
if (mDiskWritesInFlight > 0) {
mMap = new HashMap<String, Object>(mMap);
}
mcr.mapToWriteToDisk = mMap;
mDiskWritesInFlight++;
//是否有監(jiān)聽key改變的監(jiān)聽者
boolean hasListeners = mListeners.size() > 0;
if (hasListeners) {
mcr.keysModified = new ArrayList<String>();
mcr.listeners = new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
}
synchronized (this) {
//當mClear為true, 則直接清空mMap
if (mClear) {
if (!mMap.isEmpty()) {
mcr.changesMade = true;
mMap.clear();
}
mClear = false;
}
for (Map.Entry<String, Object> e : mModified.entrySet()) {
String k = e.getKey();
Object v = e.getValue();
//注意此處的this是個特殊值, 用于移除相應的key操作.
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; // changesMade代表數(shù)據(jù)是否有改變
if (hasListeners) {
mcr.keysModified.add(k); //記錄發(fā)生改變的key
}
}
mModified.clear(); //清空EditorImpl中的mModified數(shù)據(jù)
}
}
return mcr;
}
該方法的主要功能: 把EditorImpl數(shù)據(jù)更新到SPI.
- 將mMap信息賦值給mapToWriteToDisk, 并mDiskWritesInFlight加1;
- 當mClear為true, 則直接清空mMap;
- 當value值為this或null, 則移除相應的key;
- 當value值發(fā)生改變, 則會更新到mMap;
只要有key/value發(fā)生改變(新增, 刪除), 則設置mcr.changesMade = true. 最后會清空EditorImpl中的mModified數(shù)據(jù).
4.3 enqueueDiskWrite
[-> SharedPreferencesImpl.java]
private void enqueueDiskWrite(final MemoryCommitResult mcr, final Runnable postWriteRunnable) {
final Runnable writeToDiskRunnable = new Runnable() {
public void run() {
synchronized (mWritingToDiskLock) {
//執(zhí)行文件寫入操作[見小節(jié)4.3.1]
writeToFile(mcr);
}
synchronized (SharedPreferencesImpl.this) {
mDiskWritesInFlight--;
}
//此時postWriteRunnable為null不執(zhí)行該方法
if (postWriteRunnable != null) {
postWriteRunnable.run();
}
}
};
final boolean isFromSyncCommit = (postWriteRunnable == null);
if (isFromSyncCommit) { //commit方法會進入該分支
boolean wasEmpty = false;
synchronized (SharedPreferencesImpl.this) {
//commitToMemory過程會加1,則wasEmpty=true
wasEmpty = mDiskWritesInFlight == 1;
}
if (wasEmpty) {
//跳轉到上面
writeToDiskRunnable.run();
return;
}
}
//不執(zhí)行該方法
QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
}
4.3.1 writeToFile
private void writeToFile(MemoryCommitResult mcr) {
if (mFile.exists()) {
if (!mcr.changesMade) { //沒有key發(fā)生改變, 則直接返回
mcr.setDiskWriteResult(true);
return;
}
if (!mBackupFile.exists()) {
//當備份文件不存在, 則把mFile重命名為備份文件
if (!mFile.renameTo(mBackupFile)) {
mcr.setDiskWriteResult(false);
return;
}
} else {
mFile.delete(); //否則,直接刪除mFile
}
}
try {
FileOutputStream str = createFileOutputStream(mFile);
if (str == null) {
mcr.setDiskWriteResult(false);
return;
}
//將mMap全部信息寫入文件
XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);
FileUtils.sync(str);
str.close();
ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0);
try {
final StructStat stat = Os.stat(mFile.getPath());
synchronized (this) {
mStatTimestamp = stat.st_mtime;
mStatSize = stat.st_size;
}
} catch (ErrnoException e) {
...
}
//寫入成功, 則刪除備份文件
mBackupFile.delete();
//返回寫入成功, 喚醒等待線程
mcr.setDiskWriteResult(true);
return;
} catch (XmlPullParserException e) {
...
} catch (IOException e) {
...
}
//如果寫入文件的操作失敗, 則刪除未成功寫入的文件
if (mFile.exists()) {
if (!mFile.delete()) {
...
}
}
//返回寫入失敗, 喚醒等待線程
mcr.setDiskWriteResult(false);
}
該方法的主要功能:
- 當沒有key發(fā)生改變, 則直接返回; 否則執(zhí)行step2;
- 將mMap全部信息寫入文件, 如果寫入成功則刪除備份文件,如果寫入失敗則刪除mFile.
可見, 每次commit是把全部數(shù)據(jù)更新到文件, 所以每個文件的數(shù)據(jù)量必須保證足夠精簡. 再來看看apply過程.
4.4 apply
[-> SharedPreferencesImpl.java:: EditorImpl]
public void apply() {
//把數(shù)據(jù)更新到內存[見小節(jié)4.2]
final MemoryCommitResult mcr = commitToMemory();
final Runnable awaitCommit = new Runnable() {
public void run() {
try {
//進入等待狀態(tài)
mcr.writtenToDiskLatch.await();
} catch (InterruptedException ignored) {
}
}
};
//將awaitCommit添加到QueuedWork
QueuedWork.add(awaitCommit);
Runnable postWriteRunnable = new Runnable() {
public void run() {
awaitCommit.run();
//從QueuedWork移除
QueuedWork.remove(awaitCommit);
}
};
//[見小節(jié)4.4.1]
SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
notifyListeners(mcr);
}
4.4.1 enqueueDiskWrite
[-> SharedPreferencesImpl.java]
private void enqueueDiskWrite(final MemoryCommitResult mcr, final Runnable postWriteRunnable) {
final Runnable writeToDiskRunnable = new Runnable() {
public void run() {
synchronized (mWritingToDiskLock) {
//執(zhí)行文件寫入操作[見小節(jié)4.3.1]
writeToFile(mcr);
}
synchronized (SharedPreferencesImpl.this) {
mDiskWritesInFlight--;
}
if (postWriteRunnable != null) {
postWriteRunnable.run();
}
}
};
final boolean isFromSyncCommit = (postWriteRunnable == null);
if (isFromSyncCommit) {
... //postWriteRunnable不為空
}
//將任務放入單線程的線程池來執(zhí)行
QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
}
4.4.2 QueuedWork
[-> QueuedWork.java]
public class QueuedWork {
private static final ConcurrentLinkedQueue<Runnable> sPendingWorkFinishers =
new ConcurrentLinkedQueue<Runnable>();
public static void add(Runnable finisher) {
sPendingWorkFinishers.add(finisher);
}
public static void remove(Runnable finisher) {
sPendingWorkFinishers.remove(finisher);
}
public static void waitToFinish() {
Runnable toFinish;
while ((toFinish = sPendingWorkFinishers.poll()) != null) {
toFinish.run();
}
}
public static boolean hasPendingWork() {
return !sPendingWorkFinishers.isEmpty();
}
}
可見, apply跟commit的最大區(qū)別 在于apply的寫入文件操作是在單線程的線程池來完成.
- apply方法開始的時候, 會把awaitCommit放入QueuedWork;
- 文件寫入操作完成, 則會把相應的awaitCommit從QueuedWork中移除.
QueuedWork在這里存在的價值主要是用于在Stop Service, finish BroadcastReceiver過程用于 判定是否處理完所有的異步SP操作.
五. 總結
apply 與commit的對比
- apply沒有返回值, commit有返回值能知道修改是否提交成功
- apply是將修改提交到內存，再異步提交到磁盤文件; commit是同步的提交到磁盤文件;
- 多并發(fā)的提交commit時，需等待正在處理的commit數(shù)據(jù)更新到磁盤文件后才會繼續(xù)往下執(zhí)行，從而降低效率; 而apply只是原子更新到內存，后調用apply函數(shù)會直接覆蓋前面內存數(shù)據(jù)，從一定程度上提高很多效率。
獲取SP與Editor:
- getSharedPreferences()是從ContextImpl.sSharedPrefsCache唯一的SPI對象;
- edit()每次都是創(chuàng)建新的EditorImpl對象.
優(yōu)化建議:
- 請不要高頻地使用apply, 盡可能地批量提交;commit直接在主線程操作, 更要注意了
- 不要使用MODE_MULTI_PROCESS;
- 高頻寫操作的key與高頻讀操作的key可以適當?shù)夭鸱治募? 由于減少同步鎖競爭;
- 不要一上來就執(zhí)行getSharedPreferences().edit(), 應該分成兩大步驟來做, 中間可以執(zhí)行其他代碼.
- 不要連續(xù)多次edit(), 應該獲取一次獲取edit(),然后多次執(zhí)行putxxx(), 減少內存波動; 經(jīng)?？吹酱蠹蚁矚g封裝方法, 結果就導致這種情況的出現(xiàn).
- 每次commit時會把全部的數(shù)據(jù)更新的文件, 所以整個文件是不應該過大的, 影響整體性能;
