SP的特點以及基本使用方式

SharedPreferences因非常適合存儲較小鍵值集合數據且使用非常簡單的特點，而受到廣大程序員們熱愛。
SP使用非常簡單:

//讀操作 Context context = getActivity(); SharedPreferences sp = getSharedPreferences("fileName", Context.MODE_PRIVATE); String result = sp.getString("key", "defaultValue");//寫操作 Context context = getActivity(); SharedPreferences sp = getSharedPreferences("fileName", Context.MODE_PRIVATE); sp.edit().putString("key", "value").commit();

SP源碼分析

SP是如何讀取數據的

其實Context實現就是ContextImpl中，要想搞清楚SP是如何讀取數據的，第一步當然是要了解ContextImpl.getSharedPreferences方法是如何實現的

/*** Map from package name, to preference name, to cached preferences.*///緩存所有應用的SP容器,該容器key對應應用名稱，value則為每個應用存儲所有sp的容器(ArrayMap)private static ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>> sSharedPrefs;@Overridepublic SharedPreferences getSharedPreferences(String name, int mode) {SharedPreferencesImpl sp;synchronized (ContextImpl.class) {if (sSharedPrefs == null) {//如果靜態對象不存在，直接創建一個Map，以便后期用于保存spsSharedPrefs = new ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>>();}//獲取當前應用包名final String packageName = getPackageName();//從保存sp的容器中通過包名查找當前應用所有sp；每個app的所有sp都是保存在ArrayMap中，ArrayMap<String, SharedPreferencesImpl> packagePrefs = sSharedPrefs.get(packageName);if (packagePrefs == null) {//如果從sp容器沒找到保存當前應用sp的ArrayMap直接創建一個packagePrefs = new ArrayMap<String, SharedPreferencesImpl>();//將創建的對象保存到sp容器中sSharedPrefs.put(packageName, packagePrefs);}// 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) {//如果targetSdk版本好小于19，且傳入的文件名為null的話，默認將文件名命名為"null"if (name == null) {name = "null";}}//從當前應用的sp容器中通過文件名去查找spsp = packagePrefs.get(name);if (sp == null) {//如果沒找到，直接創建一個文件名以name命名的xml文件File prefsFile = getSharedPrefsFile(name);//此處極為關鍵，該構造器是讀取文件操作sp = new SharedPreferencesImpl(prefsFile, mode);//將創建sp對象保存到當前應用sp容器中packagePrefs.put(name, 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.//如果讀取模式是跨線程或targetSdk版本小于11，再次重新load下文件而已sp.startReloadIfChangedUnexpectedly();}return sp;}

從上面源碼可以看出，getSharedPreferences方法是先根據當前應用名稱來獲取一個ArrayMap（存儲sp的容器）如果沒有直接創建并保存到內存中，然后再根據文件名來獲取SharedPreferencesImpl的對象(沒找到則直接創建SharedPreferencesImpl)，這短短的三十幾行代碼還是比較簡單的。
因為是靜態變量存儲鍵值數據的所以我們用SP存儲的數據在內存中是一直存在；所以我們盡量用一個文件來存在數據，以達到減少內存對象

大家可以看到getSharePreferences返回的對象類型其實是SharedPreferencesImpl類型，只不過該類實現了SharedPreferences接口而已，接下來我們先看看SharedPreferencesImpl構造器做了啥東東。

SharedPreferencesImpl.java

final class SharedPreferencesImpl implements SharedPreferences {private final File mFile;private final File mBackupFile;private final int mMode;private Map<String, Object> mMap; // guarded by 'this'private int mDiskWritesInFlight = 0; // guarded by 'this'//文件是否加載成功private boolean mLoaded = false; // guarded by 'this'//文件的時間以及大小private long mStatTimestamp; // guarded by 'this'private long mStatSize; // guarded by 'this'private final Object mWritingToDiskLock = new Object();private static final Object mContent = new Object();private final WeakHashMap<OnSharedPreferenceChangeListener, Object> mListeners =new WeakHashMap<OnSharedPreferenceChangeListener, Object>();SharedPreferencesImpl(File file, int mode) {//給類成員變量賦值mFile = file;mBackupFile = makeBackupFile(file);mMode = mode;mLoaded = false;mMap = null;//開啟一個線程讀取文件startLoadFromDisk();}private static File makeBackupFile(File prefsFile) {return new File(prefsFile.getPath() + ".bak");}private void startLoadFromDisk() {synchronized (this) {//使用同步代碼代碼塊，對mloader進行賦值mLoaded = false;}//開啟線程讀取文件new Thread("SharedPreferencesImpl-load") {public void run() {synchronized (SharedPreferencesImpl.this) {loadFromDiskLocked();}}}.start();}private void loadFromDiskLocked() {//如果文件已經加載完畢直接返回if (mLoaded) {return;}if (mBackupFile.exists()) {mFile.delete();mBackupFile.renameTo(mFile);}// Debuggingif (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 = XmlUtils.readMapXml(str);} catch (XmlPullParserException e) {Log.w(TAG, "getSharedPreferences", e);} catch (FileNotFoundException e) {Log.w(TAG, "getSharedPreferences", e);} catch (IOException e) {Log.w(TAG, "getSharedPreferences", e);} finally {IoUtils.closeQuietly(str);}}} catch (ErrnoException e) {}//修改文件加載完成標志mLoaded = true;if (map != null) {mMap = map;//如果有數據，將數據已經賦值給類成員變量mMap，mStatTimestamp = stat.st_mtime;//記錄文件上次修改時間mStatSize = stat.st_size;//記錄文件大小(字節單位)} else {//沒有數據直接創建一個hashmap對象mMap = new HashMap<String, Object>();}//此處非常關鍵是為了通知其他線程文件已讀取完畢，你們可以執行讀／寫操作了notifyAll();}}

通過上述分析我們不難發現調用getSharedPreferences方法就已經開啟一個線程去讀取文件了
我們再來看看SharedPreferencesImpl.getString內部是如何執行的

@Nullable public String getString(String key, @Nullable String defValue) {synchronized (this) {//此處會阻塞當前線程，直到文件讀取完畢awaitLoadedLocked();//從類成員變量mMap中直接讀取數據，沒有直接返回默認值String v = (String)mMap.get(key);return v != null ? v : defValue;} }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) {try {wait();} catch (InterruptedException unused) {}}}

至此關于SP的讀操作以全部分析完畢，相信大家對SP讀操作有了更深入的認識了；下面我們繼續再看看SP的寫操作是怎么玩的

SP是如何寫入數據的

通常寫數據大體是這樣的

//寫操作 Context context = getActivity(); SharedPreferences sp = getSharedPreferences("fileName", Context.MODE_PRIVATE); sp.edit().putString("key", "value").commit();

getSharedPreferences大家都很清楚了，我們現在edit方法到底做了什么

public Editor edit() {// TODO: remove the need to call awaitLoadedLocked() when// requesting an editor. will require some work on the// Editor, but then we should be able to do://// context.getSharedPreferences(..).edit().putString(..).apply()//// ... all without blocking.synchronized (this) {awaitLoadedLocked();}return new EditorImpl(); }

可以看到edit方法非常簡單，首先是通過同步代碼塊調用了awaitLoadedLocked方法，緊接著直接返回了一個EditorImpl實例對象，我們繼續追蹤看看EditorImpl類是put、commit方法

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 Editor remove(String key) {synchronized (this) {//注意此處并沒有執行刪除操作，而是將其對應key的value設置了當前this//commitToMemory方法中會對此做特殊處理mModified.put(key, this);return this;}}public Editor clear() {synchronized (this) {mClear = true;return this;}}public boolean commit() {//第一步 commitToMemory方法可以理解為對SP中的mMap對象同步到最新數據狀態MemoryCommitResult mcr = commitToMemory();//第二步 寫文件；注意第二個參數為null，寫文件操作會運行在當前線程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;}... }

從上面可以看到，其實putXXX方法知識把鍵值數據先存放到內存中去了(mModified對象中)；比較有意思到是remove、clear方法，remove方法會將要刪除的數據的value設置為EditorImpl自己(commitToMemory方法會對此做特殊處理)；
clear方法也僅僅是設置一個標志位而已(commitToMemory方法中用到)；
最關鍵的方法還是commit方法，我們可以看到其實commit方法主要分為四步，第一步將sp數據同步到最新狀態并返回mcr對象；第二步將mcr對象中數據寫入文件；第三步通知監聽器數據已發生改變；最后一步就是返回寫操作狀態是否成功

public final class EditorImpl implements Editor {//可以最后看，和commit主要區別就是apply的寫文件操作會在一個線程中執行，不會阻塞UI線程public void apply() {final MemoryCommitResult mcr = commitToMemory();final Runnable awaitCommit = new Runnable() {public void run() {try {mcr.writtenToDiskLatch.await();} catch (InterruptedException ignored) {}}};//將awaitCommit任務提交到一個隊列中QueuedWork.add(awaitCommit);Runnable postWriteRunnable = new Runnable() {public void run() {//寫文件操作完成后會執行此2行代碼（如果寫操作未結束，當前頁面已經銷毀寫操作的數據會丟失？這個切入點主要看QueuedWork的waitToFinish方法何時調用就明白了，有興趣同學可以自己研究下）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);}// Returns true if any changes were madeprivate MemoryCommitResult commitToMemory() {//創建一個對象MemoryCommitResult mcr = new MemoryCommitResult();synchronized (SharedPreferencesImpl.this) {// We optimistically don't make a deep copy until// a memory commit comes in when we're already// writing to disk.if (mDiskWritesInFlight > 0) {// We can't modify our mMap as a currently// in-flight write owns it. Clone it before// modifying it.// noinspection uncheckedmMap = new HashMap<String, Object>(mMap);}mcr.mapToWriteToDisk = mMap;mDiskWritesInFlight++;//如果sp注冊了多個監聽器，將其賦值給mcr對象boolean hasListeners = mListeners.size() > 0;if (hasListeners) {mcr.keysModified = new ArrayList<String>();mcr.listeners =new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());}synchronized (this) {//如果調用了clear方法，判斷sp中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" 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.//如果對應的值為它自己EditorImpl或為nullif (v == this || v == null) {//如果sp的數據結合沒有該鍵值對，直接進入下一個循環if (!mMap.containsKey(k)) {continue;}//有該鍵值集合直接刪除，因為remove方法其實存放的就是EditorImpl對象mMap.remove(k);} else {//將要寫入的鍵值數據，同步到sp的mMap中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);}}//結尾清空EditorImpl中mModified數據mModified.clear();}}return mcr;}private void notifyListeners(final MemoryCommitResult mcr) {//注意監聽器的回調方法都是在UI線程執行的if (mcr.listeners == null || mcr.keysModified == null ||mcr.keysModified.size() == 0) {return;}if (Looper.myLooper() == Looper.getMainLooper()) {for (int i = mcr.keysModified.size() - 1; i >= 0; i--) {final String key = mcr.keysModified.get(i);for (OnSharedPreferenceChangeListener listener : mcr.listeners) {if (listener != null) {listener.onSharedPreferenceChanged(SharedPreferencesImpl.this, key);}}}} else {// Run this function on the main thread.ActivityThread.sMainThreadHandler.post(new Runnable() {public void run() {notifyListeners(mcr);}});}} }// Return value from EditorImpl#commitToMemory() private static class MemoryCommitResult {public boolean changesMade; // any keys different?public List<String> keysModified; // may be nullpublic Set<OnSharedPreferenceChangeListener> listeners; // may be nullpublic Map<?, ?> mapToWriteToDisk;//一個計數器，用來實現寫文件線程通知其他線程寫操作已經完成的功能，public final CountDownLatch writtenToDiskLatch = new CountDownLatch(1);//本次寫操作狀態結果public volatile boolean writeToDiskResult = false;public void setDiskWriteResult(boolean result) {writeToDiskResult = result;writtenToDiskLatch.countDown();} }SharePreferenceImpl.java /*** Enqueue an already-committed-to-memory result to be written* to disk.** They will be written to disk one-at-a-time in the order* that they're enqueued.** @param postWriteRunnable if non-null, we're being called* from apply() and this is the runnable to run after* the write proceeds. if null (from a regular commit()),* then we're allowed to do this disk write on the main* thread (which in addition to reducing allocations and* creating a background thread, this has the advantage that* we catch them in userdebug StrictMode reports to convert* them where possible to apply() ...)*/ private void enqueueDiskWrite(final MemoryCommitResult mcr,final Runnable postWriteRunnable) {final Runnable writeToDiskRunnable = new Runnable() {public void run() {synchronized (mWritingToDiskLock) {//持有mWritingToDiskLock鎖后，執行寫文件操作writeToFile(mcr);}synchronized (SharedPreferencesImpl.this) {//寫操作數減一mDiskWritesInFlight--;}if (postWriteRunnable != null) {//文件寫入操作完成后，執行后續動作；apply方法會執行到次postWriteRunnable.run();}}};//判斷是不是調用commit方法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) {//如果是commit方法，直接在當前線程執行；可以看出如果當前是UI線程，會阻塞UI線程，引起界面卡頓writeToDiskRunnable.run();return;}}//如果不是commit是apply方法，writeToDiskRunnable任務會被提交到一個單個線程的線程池中執行QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable); }// Note: must hold mWritingToDiskLock private void writeToFile(MemoryCommitResult mcr) {// Rename the current file so it may be used as a backup during the next readif (mFile.exists()) {//如果文件存在且數據未發生改變，沒有必要執行無用的寫入操作，直接通知并返回即可if (!mcr.changesMade) {// If the file already exists, but no changes were// made to the underlying map, it's wasteful to// re-write the file. Return as if we wrote it// out.mcr.setDiskWriteResult(true);return;}//文件存在且備份文件不存在if (!mBackupFile.exists()) {//嘗試將文件設置為備份文件(重命名)(此時只有備份文件，mFile對應的文件已經沒有了)；如果操作不成功，通知并返回；因為下面到操作是寫入數據到mFile中，所以我們先要備份數據，這樣即使寫入數據失敗時，我們還可以使用備份數據if (!mFile.renameTo(mBackupFile)) {Log.e(TAG, "Couldn't rename file " + mFile+ " to backup file " + mBackupFile);mcr.setDiskWriteResult(false);return;}} else {//如果備份文件存在，直接刪除mFile，因為接下來要重新寫入mFile了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 {//創建一個文件輸出流，用于寫入數據到mFile中FileOutputStream str = createFileOutputStream(mFile);if (str == null) {//創建失敗直接返回mcr.setDiskWriteResult(false);return;}//寫入數據到mFile中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) {// Do nothing}// Writing was successful, delete the backup file if there is one.mBackupFile.delete();//寫入數據成功，則刪除備份文件；因為所有數據都寫入mFile中mcr.setDiskWriteResult(true);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 fileif (mFile.exists()) {//寫入過程中出現異常則刪除mFile，下次可以直接從備份文件中讀取if (!mFile.delete()) {Log.e(TAG, "Couldn't clean up partially-written file " + mFile);}}mcr.setDiskWriteResult(false); }private static FileOutputStream createFileOutputStream(File file) {FileOutputStream str = null;try {str = new FileOutputStream(file);} catch (FileNotFoundException e) {File parent = file.getParentFile();if (!parent.mkdir()) {Log.e(TAG, "Couldn't create directory for SharedPreferences file " + file);return null;}FileUtils.setPermissions(parent.getPath(),FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH,-1, -1);try {str = new FileOutputStream(file);} catch (FileNotFoundException e2) {Log.e(TAG, "Couldn't create SharedPreferences file " + file, e2);}}return str; }void startReloadIfChangedUnexpectedly() {synchronized (this) {// TODO: wait for any pending writes to disk?if (!hasFileChangedUnexpectedly()) {return;}//可以看到如果被文件被別的進程修改過，重新加載下文件而已startLoadFromDisk();} }// Has the file changed out from under us? i.e. writes that // we didn't instigate. //判斷文件是不是已經被別人(別的進程)修改了？ private boolean hasFileChangedUnexpectedly() {synchronized (this) {if (mDiskWritesInFlight > 0) {// If we know we caused it, it's not unexpected.if (DEBUG) Log.d(TAG, "disk write in flight, not unexpected.");//如果是自己修改，直接返回falsereturn false;}}final StructStat stat;try {/** Metadata operations don't usually count as a block guard* violation, but we explicitly want this one.*/BlockGuard.getThreadPolicy().onReadFromDisk();stat = Os.stat(mFile.getPath());} catch (ErrnoException e) {return true;}//根據文件上次修改時間以及大小二個屬性來判讀是否別的進程修改過synchronized (this) {return mStatTimestamp != stat.st_mtime || mStatSize != stat.st_size;} }

相信大家應該SP的讀寫有了更深刻的認識!

總結

以上是生活随笔為你收集整理的Android-带你从源码角度理解SharedPreferences存储原理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。