一、概述
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/