SharedPreferences解析
一、概述
SharedPreferences(简称SP)是Android中很常用的数据存储方式，SP采用key-value(键值对)形式，主要用于轻量级的数据存储，尤其适合保存应用的配置参数，但不建议使用SP来存储大规模的数据，可能会降低性能。
SP采用xml文件格式来保存数据，改文件所在目录位于/data/data/shared_prefs/。
二、使用
1.得到SharedPreferences对象
private SharedPreferences mSharedPreferences; private final static String PREFRENCE_FILE_KEY = "com.zhangmiao.shared_preferences"; mSharedPreferences = getSharedPreferences(PREFRENCE_FILE_KEY, MODE_PRIVATE);
2.添加数据
final SharedPreferences.Editor editor = mSharedPreferences.edit(); editor.putInt("id",1); editor.putString("name","小熊"); editor.putInt("age",24); editor.commit();
3.获取数据
TextView textView = (TextView)findViewById(R.id.text); String message = "id = " + mSharedPreferences.getInt("id",-1) + ",name = " + mSharedPreferences.getString("name","无") + ",age = " + mSharedPreferences.getInt("age",-1)+"。"; textView.setText(message);
4.查看生成的sharedpreferences.xml文件
我使用的是adb命令查看的文件，命令如下：（系统是window10）
adb shell
run-as com.zhangmiao.myapplication(应用包名)
ls(查看xml文件的名称)
cat com.zhangmiao.shared_preferences.xml(查看xml文件)
三、解析SharedPreferences
1.获取方式
1.1.getSharedPreferences(String name, int mode)
@Override public SharedPreferences getSharedPreferences(String name, int mode) { return mBase.getSharedPreferences(name, mode); }
这里的mBase就是Context类，Context的具体实现类是ContextImpl类，所以直接查看ContextImpl类中的getSharedPreferences方法。
@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<>(); } file = mSharedPrefsPaths.get(name); if (file == null) { file = getSharedPreferencesPath(name);【1.3】 mSharedPrefsPaths.put(name, file); } } return getSharedPreferences(file, mode);【1.2】 }
第一步：判断版本号是否小于17，如果是，判断name是否为null，如果是，则设置name为“null”。
第二步：同步ContextImpl.class，如果mSharedPrefsPaths为null，则初始化mSharedPrefsPath，判断name对应的file是否为null，则调用getSharedPreferencesPath(name)初始化file，并加入mSharedPrefsPaths中。
第三步：返回getSharedPreferences(file, mode)方法。
1.2.public SharedPreferences getSharedPreferences(File file, int mode)
@Override public SharedPreferences getSharedPreferences(File file, int mode) { checkMode(mode);【1.4】 SharedPreferencesImpl sp; synchronized (ContextImpl.class) { final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();【1.5】 sp = cache.get(file); if (sp == null) { sp = new SharedPreferencesImpl(file, mode); cache.put(file, sp); return sp; } } if ((mode & Context.MODE_MULTI_PROCESS) != 0 || getApplicationInfo().targetSdkVersion < 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; }
第一步：检查mode的类型，如果没有MODE_WORLD_READABLE与MODE_WORLD_WRITEABLE，则抛出异常。
第二步：使用getSharedPreferencesCacheLocked()方法，得到cache数组映射，得到file对应的sp，如果为空，初始化并家务cache中。
第三步：调用sp的startReloadIfChangedUnexpectedly()方法。
1.3.public File getSharedPreferencesPath(String name)
@Override public File getSharedPreferencesPath(String name) { return makeFilename(getPreferencesDir(), name + ".xml"); }
继续查看makeFileName()方法
private File makeFilename(File base, String name) { if (name.indexOf(File.separatorChar) < 0) { return new File(base, name); } throw new IllegalArgumentException( "File " + name + " contains a path separator"); }
如果name包含文件分隔符则生成xml文件，否则抛出异常。
1.4.private void checkMode(int mode)
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"); } } }
如果sdk的版本大于等于24，则mode包含MODE_WORLD_READABLE与MODE_WORLD_WRITEABLE则抛出异常。意思是从版本24开始，创建的SP文件模式，不允许MODE_WORLD_READABLE和MODE_WORLD_WRITEABLE模块。
当设置MODE_MULTI_PROCESS模式，则每次getSharedPreferences过程，会检查SP文件上次修改时间和文件大小，一旦所有修改则会重新从磁盘加载文件。
1.5.private ArrayMap<File, SharedPreferencesImpl> getSharedPreferencesCacheLocked()
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为null，则初始化它。
第二步：调用getPackageName()方法得到packageName。
第三步：得到sSharedPrefsCache中packageName对应的ArrayMap对象packagePrefs。
第四步：如果packagePrefs为null,则初始化它，并且添加到sSharedPrefsCache中。
总结：获取SharedPreference只要实现在ContextImpl中，mSharedPrefsPaths包含name对应的File，sSharedPrefsCache中包含packageName对应的packagePrefs，packagePrefs中包含File对应的SharedPreferencesImpl。
而获取过程主要时生成File文件，初始化上面的三个ArrayMap，将本应用相关的数据添加进去，以及检测版本与mode，并抛出异常。
2.添加数据
添加数据使用到SharedPreferences.Editor类，SharedPreferences的实现是在ShredPreferencesImpl中，SharedPreferences.Editor的具体实现在ShredPreferencesImpl.EditorImpl中。
2.1.public Editor 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();【2.2】 } return new EditorImpl(); }
同步this，调用awaitLoadedLocked()方法，返回EditorImpl对象。
2.2.private void awaitLoadedLocked()
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) { } } }
第一步：如果mLoaded为false，则调用BlockGuard.getThreadPolicy().onReadFromDisk()方法，忽略无用的线程。
第二步：如果mLoaded为false，没有加载完成，则等待。
2.3.put***(String key, *** value)系列方法
put***()方法基本相同，这里以putInt(String key, int value)为例介绍：
public Editor putInt(String key, int value) { synchronized (this) { mModified.put(key, value); return this; } }
同步this，将数据添加到mModified中，this是Editor对象。
2.4.public Editor remove(String key)
public Editor remove(String key) { synchronized (this) { mModified.put(key, this); return this; } }
同步this，添加到mModified的数据为key与this。
2.5.public Editor clear()
public Editor clear() { synchronized (this) { mClear = true; return this; } }
设置mClear为true。
2.6.public boolean commit()
public boolean commit() { MemoryCommitResult mcr = commitToMemory();【2.7】 SharedPreferencesImpl.this.enqueueDiskWrite(【2.9】 mcr, null /* sync write on this thread okay */); try { mcr.writtenToDiskLatch.await(); } catch (InterruptedException e) { return false; } notifyListeners(mcr);【2.8】 return mcr.writeToDiskResult; }
第一步：调用commitToMemory()方法，得到mcr对象。
第二步：调用SharedPreferencesImpl的enqueueDiskWrite()方法。
第三步：调用mcr,writtenToDiskLatch.await()方法。
第四步：调用notifyListeners(mcr)方法。
2.7.private MemoryCommitResult commitToMemory()
private 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 unchecked mMap = new HashMap<String, Object>(mMap); } mcr.mapToWriteToDisk = mMap; mDiskWritesInFlight++; boolean hasListeners = mListeners.size() > 0; if (hasListeners) { mcr.keysModified = new ArrayList<String>(); mcr.listeners = new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet()); } synchronized (this) { 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. 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; if (hasListeners) { mcr.keysModified.add(k); } } mModified.clear(); } } return mcr; }
第一步：同步SharedPreferencesImpl.this。
第二步：如果mDiskWritesInFlinght大于0，则初始化mMap。
第三步：设置mcr.mapToWriteToDisk为mMap，mDiskWritesInFlight加1。
第四步：如果存在listener，初始化mcr的keysModified和listeners。
第五步：同步this，如果mClear为true，调用mMap.clear()；遍历mModified，如果value为this，则调用mMap.remove(k)方法，移除关键字；如果不是this，先判断mMap是否包含k与value，不包含，则调用mMap.put(k,v)，在mcr.keysModified中添加k。
第六步：调用mModified.clear()方法。
2.8.private void notifyListeners(final MemoryCommitResult mcr)
private void notifyListeners(final MemoryCommitResult mcr) { 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); } }); } }
第一步：如果mcr.listeners为null或者mcr.keysModified为null或者mcr.keysModified.size()等于0，则直接返回。
第二步：如果当前looper是mainLooper，遍历mcr.keysModified，得到mcr.keysModified.get(i)为key,遍历scr.Listeners，调用listener.onSharedPreferenceChanged()方法。
第三步：如果不是mainLooper，则在主线程中调用notifyListeners(mcr)方法。
2.9.private void enqueueDiskWrite(final MemoryCommitResult mcr, final Runnable postWriteRunnable)
private void enqueueDiskWrite(final MemoryCommitResult mcr, final Runnable postWriteRunnable) { final Runnable writeToDiskRunnable = new Runnable() { public void run() { synchronized (mWritingToDiskLock) { writeToFile(mcr);【2.10】 } synchronized (SharedPreferencesImpl.this) { mDiskWritesInFlight--; } if (postWriteRunnable != null) { postWriteRunnable.run(); } } }; 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) { writeToDiskRunnable.run(); return; } } QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable); }
第一步：创建writeToDiskRunnable线程，同步mWritingToDiskLock，调用writeFile(mcr)执行文件写入操作，同步SharedPreferencesImpl.this,将mDiskWritesInFlight减一，如果postWriteRunnable不为null，则运行postWriteRunnable。
第二步：如果isFromSyncCommit为true（commit方法会进入），同步ShreadPreferencesImpl.this，设置wasEmpty的值（因为commitToMemory过程会加1，则wasEmpty为true）；如果wasEmpty为true，运行wirteToDiskRunnable线程，然后返回。
第三步：调用QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable)方法。
2.10.private void writeToFile(MemoryCommitResult mcr)
// Note: must hold mWritingToDiskLock private void writeToFile(MemoryCommitResult mcr) { // Rename the current file so it may be used as a backup during the next read if (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()) { if (!mFile.renameTo(mBackupFile)) { Log.e(TAG, "Couldn't rename file " + mFile + " to backup file " + mBackupFile); mcr.setDiskWriteResult(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 (str == null) { mcr.setDiskWriteResult(false); return; } 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(); 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 file if (mFile.exists()) { if (!mFile.delete()) { Log.e(TAG, "Couldn't clean up partially-written file " + mFile); } } mcr.setDiskWriteResult(false); }
第一步：如果mFile存在，如果mcr.changesMade为false(没有key发生改变，则直接饭后),设置mcr的DiskWriteResult为true,返回。如果mBackupFile不存在，则将mFile重命名为mBackupFile，设置mcr的DiskWriteResult为false,如果mBackupFile存在，则直接删除mFile。
第二步：将mMap全部信息写去文件中，调用Context.setFilePermissionsFromMode()方法。
第三步：得到Os.stat(mFile.getPath())的stat，设置mStatTimestamp与mStatSize。
第四步：写入成功后，删除mBackupFile备份文件。
第五步：设置mcr的DiskWriteResult为true，返回写入成功，唤醒等待线程。
第六步：如果文件mFile存在，则删除mFile，如果写入文件的操作失败，则删除未成功写入的文件。
第七步：设置mcr的DiskWriteResult为true，返回写入失败，唤醒等待线程。
2.11.public void apply()
public void apply() { final MemoryCommitResult mcr = commitToMemory();【2.7】 final Runnable awaitCommit = new Runnable() { public void run() { try { mcr.writtenToDiskLatch.await(); } catch (InterruptedException ignored) { } } }; QueuedWork.add(awaitCommit); Runnable postWriteRunnable = new Runnable() { public void run() { 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);【2.8】 }
第一步：调用commitToMemory()方法。
第二步：创建线程awaitCommit调用mcr.writtenToDiskLatch.await()方法。
第三步：在QueuedWork添加awaitCommit线程。
第四步：创建线程postWriteRunnable调用awaitCommit.run()方法，从QueuedWork中移除awaitCommit。
第五步：调用SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable)方法。
第六步：调用notifyListeners(mcr)方法。
总结：所有的put、clear、remove都加了同步锁，如果有多次调用putString，建议使用putStringSet方法，减少锁的消耗。
edit()每次都是创建新的EditorImpl对象，getSharedPreferences()是从ContextImpl.sSharedPrefsCache唯一的SPI对象。
commit与apply的区别：
（1）apply没有返回值；commit有返回值能知道修改是否提交成功。
（2）apply是将修改提交到内存中，再异步提交到磁盘文件；commit是同步地提交到磁盘文件。
（3）多并发的提交commit是，需等待正在处理的commit数据更新到磁盘文件后才会继续往下执行，从而降低效率；而apply只是原子更新到内存，后调用apply函数会直接覆盖前面内存数据，从一定程度上提高很多效率。
3.获取数据
3.1.public Map<String, ?> getAll()
public Map<String, ?> getAll() { synchronized (this) { awaitLoadedLocked(); //noinspection unchecked return new HashMap<String, Object>(mMap); } }
第一步：调用awaitLoadedLocked()方法。
第二步：返回mMap的HashMap。
3.2.public String get***(String key, @Nullable *** defValue)
get***方法的实现基本相同，这里以getString()方法为例介绍。
@Nullable public String getString(String key, @Nullable String defValue) { synchronized (this) { awaitLoadedLocked(); String v = (String)mMap.get(key); return v != null ? v : defValue; } }
第一步：同步this。
第二步：调用awaitLoadedLocked()方法。
第三步，从mMap中获取key对应的value值，如果为空，则返回defValue，不为空。则返回从mMap中得到的值。
总结：所有的get都加了同步锁，
四、优化建议
1.强烈建议不要在sp里面存储特别大的key/value，有助于减少卡顿。
2.请不要高频地使用apply，尽可能地批量提交，commit直接在主线程操作，也需要主要不要高频的使用。
3.不要使用MODE_MULTI_PROCESS。
4.高频写操作的key与高频读操作的key可以适当地拆分文件，用于减少同步锁竞争。
5.不要一上来就执行getSharedPreferences().edit()，应当分成量大步骤来做，中间可以执行其他代码。
6.不要连续多次edit()，应该一次获取edit()，然后多次执行putXXX()，减少内存波动。
7.每次commit时会把所有的数据更新到文件，所以整个文件是不应该过大的，影响整体性能。
参考文章：http://gityuan.com/2017/06/18/SharedPreferences/
