一.sp是什么?能做什么?
SharedPreferences(简称SP)是Android中很常用的数据存储方式，SP采用key-value（键值对）形式, 主要用于轻量级的数据存储, 尤其适合保存应用的配置参数, 但不建议使用SP 来存储大规模的数据, 可能会降低性能.
SP采用xml文件格式来保存数据, 该文件所在目录位于/data/data//shared_prefs/
二.该怎么使用?
SharedPreferences sharedPreferences = getSharedPreferences("hello", Context.MODE_PRIVATE);
Editor editor = sharedPreferences.edit();
editor.putString("hello", "lemon");
editor.putInt("old", 3);
editor.commit();
生成的hello.xml文件内容如下：
<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
<string name="hello">"lemon"</string>
<int name="years" value="3" />
</map>
三.优缺点
四.源码解析
-
SharedPreferences与Editor只是两个接口. SharedPreferencesImpl和EditorImpl分别实现了对应接口. 另外, ContextImpl记录着SharedPreferences的重要数据, 如下:
- sSharedPrefsCache:以包名为key, 二级key是以SP文件, 以SharedPreferencesImpl为value的嵌套map结构. 这里需要sSharedPrefsCache是静态类成员变量, 每个进程是保存唯一一份, 且由ContextImpl.class锁保护.
- mSharedPrefsPaths:记录所有的SP文件, 以文件名为key, 具体文件为value的map结构;
- mPreferencesDir:是指SP所在目录, 是指/data/data//shared_prefs/
-
SP获取方式
-
getPreferences{Activity.getPreferences(mode): 以当前Activity的类名作为SP的文件名. 即xxxActivity.xml.}
public SharedPreferences getPreferences(int mode) { //[见下文] return getSharedPreferences(getLocalClassName(), mode); } -
getDefaultSharedPreferences{PreferenceManager.getDefaultSharedPreferences(Context): 以包名加上_preferences作为文件名, 以MODE_PRIVATE模式创建SP文件. 即packgeName_preferences.xml.}
public static SharedPreferences getDefaultSharedPreferences(Context context) { //[见下文] return context.getSharedPreferences(getDefaultSharedPreferencesName(context), getDefaultSharedPreferencesMode()); } -
getSharedPreferences{当然也可以直接调用Context.getSharedPreferences(name, mode), 以上所有的方法最终都是调用到如下方法:}
-
此方法是contxtimpl的具体实现:
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) { //如果文件不存在, 则创建新的文件 [见小节2.1.4] file = getSharedPreferencesPath(name); mSharedPrefsPaths.put(name, file); } } //[见小节2.2] return getSharedPreferences(file, mode); } } -
getSharedPreferencesPath{先从mSharedPrefsPaths查询是否存在相应文件;如果文件不存在, 则创建新的xml文件; 如果目录也不存在, 则先创建目录创建目录/data/data/package name/shared_prefs/;其中mSharedPrefsPaths用于记录所有的SP文件, 是以文件名为key的Map数据结构.}
public File getSharedPreferencesPath(String name) { return makeFilename(getPreferencesDir(), name + ".xml"); } private File getPreferencesDir() { synchronized (mSync) { if (mPreferencesDir == null) { //创建目录/data/data/package name/shared_prefs/ mPreferencesDir = new File(getDataDir(), "shared_prefs"); } return ensurePrivateDirExists(mPreferencesDir); } } -
getSharedPreferences
public SharedPreferences getSharedPreferences(File file, int mode) { checkMode(mode); //[见小节2.2.1] SharedPreferencesImpl sp; synchronized (ContextImpl.class) { //[见小节2.2.2] final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked(); sp = cache.get(file); if (sp == null) { //创建SharedPreferencesImpl[见小节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; } checkMode{从Android N开始, 创建的SP文件模式, 不允许MODE_WORLD_READABLE和MODE_WORLD_WRITEABLE模块, 否则会直接抛出异常SecurityException. 另外, 顺带说一下MODE_MULTI_PROCESS这种多进程的方式也是Google不推荐的方式, 后续同样会不再支持, 强烈建议App不用使用该方式来实现多个进程实现 同一个SP文件.
当设置MODE_MULTI_PROCESS模式, 则每次getSharedPreferences过程, 会检查SP文件上次修改时间和文件大小, 一旦所有修改则会重新从磁盘加载文件.}
-
-
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");
}
}
}
-
Editor
1.Editor 该过程同样要等待awaitLoadedLocked完成, 然后创建EditorImpl对象. 而EditorImpl作为SharedPreferencesImpl的内部类,其继承于Editor类.public Editor edit() { synchronized (this) { awaitLoadedLocked(); } return new EditorImpl(); //创建EditorImpl }-
EditorImpl{从这里可以看出, 这些数据修改操作仅仅是修改mModified和mClear. 直到数据提交commit或许apply过程, 才会真正的把数据更新到SharedPreferencesImpl(简称SPI). 比如设置mClear=true则会情况SPI的mMap数据.}
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对象 mModified.put(key, value); return this; } } //移除数据 public Editor remove(String key) { synchronized (this) { mModified.put(key, this); return this; } } //清空全部数据 public Editor clear() { synchronized (this) { mClear = true; return this; } } }
-
-
数据提交{这里重点来说说数据提交的两个重要方法commit()和apply().}
-
commit
public boolean commit() { //将数据更新到内存[见小节4.2] MemoryCommitResult mcr = commitToMemory(); //将内存数据同步到文件[见小节4.3] SharedPreferencesImpl.this.enqueueDiskWrite(mcr, null); try { //进入等待状态, 直到写入文件的操作完成 mcr.writtenToDiskLatch.await(); } catch (InterruptedException e) { return false; } //通知监听则, 并在主线程回调onSharedPreferenceChanged()方法 notifyListeners(mcr); // 返回文件操作的结果数据 return mcr.writeToDiskResult; }-
commitToMemory
private MemoryCommitResult commitToMemory() { MemoryCommitResult mcr = new MemoryCommitResult(); synchronized (SharedPreferencesImpl.this) { if (mDiskWritesInFlight > 0) { mMap = new HashMap<String, Object>(mMap); } mcr.mapToWriteToDisk = mMap; mDiskWritesInFlight++; //是否有监听key改变的监听者 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代表数据是否有改变 if (hasListeners) { mcr.keysModified.add(k); //记录发生改变的key } } mModified.clear(); //清空EditorImpl中的mModified数据 } } return mcr; } apply
-
-
public void apply() {
//把数据更新到内存[见小节4.2]
final MemoryCommitResult mcr = commitToMemory();
final Runnable awaitCommit = new Runnable() {
public void run() {
try {
//进入等待状态
mcr.writtenToDiskLatch.await();
} catch (InterruptedException ignored) {
}
}
};
//将awaitCommit添加到QueuedWork
QueuedWork.add(awaitCommit);
Runnable postWriteRunnable = new Runnable() {
public void run() {
awaitCommit.run();
//从QueuedWork移除
QueuedWork.remove(awaitCommit);
}
};
//[见小节4.4.1]
SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
notifyListeners(mcr);
}
可见, apply跟commit的最大区别 在于apply的写入文件操作是在单线程的线程池来完成.
五.优化
- 强烈建议不要在sp里面存储特别大的key/value, 有助于减少卡顿/anr
- 请不要高频地使用apply, 尽可能地批量提交;commit直接在主线程操作, 更要注意了
- 不要使用MODE_MULTI_PROCESS;
- 高频写操作的key与高频读操作的key可以适当地拆分文件, 由于减少同步锁竞争;
- 不要一上来就执行getSharedPreferences().edit(), 应该分成两大步骤来做, 中间可以执行其他代码,由于edit的时候包括put,set等都是阻塞方法,等加载完成之后才能执行下一个,所以当第一次执行的时候需要创建xml文件,创建完成之后需要读入内存之后才能执行edit,所以这个时候就等待了,此时可以做点其他的工作;
- 不要连续多次edit(), 应该获取一次获取edit(),然后多次执行putxxx(), 减少内存波动; 经常看到大家喜欢封装方法, 结果就导致这种情况的出现.
- 每次commit时会把全部的数据更新的文件, 所以整个文件是不应该过大的, 影响整体性能;
总结:
- 获取sp的常用的方式:
- Activity.getPreference(mode)此方式获取到的是以当前activity为名的sp
- preferenceManger.getDefaultSharedPreferences(context),此方式调用的是第三种,创建的是包名加上_preferences作为文件名,
- Context.getSharedPreferences(name, mode)
- commit()和apply().
- apply跟commit的最大区别 在于apply的写入文件操作是在单线程的线程池来完成.
- apply方法开始的时候, 会把awaitCommit放入QueuedWork;文件写入操作完成, 则会把相应的awaitCommit从QueuedWork中移除.
- apply没有返回值, commit有返回值能知道修改是否提交成功
- apply是将修改提交到内存，再异步提交到磁盘文件; commit是同步的提交到磁盘文件;
- 多并发的提交commit时，需等待正在处理的commit数据更新到磁盘文件后才会继续往下执行，从而降低效率; 而apply只是原子更新到内存，后调用apply函数会直接覆盖前面内存数据，从一定程度上提高很多效率。
