SharePreference解析

一.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文件内容如下：

三.优缺点

四.源码解析

1. SharedPreferences与Editor只是两个接口. SharedPreferencesImpl和EditorImpl分别实现了对应接口. 另外, ContextImpl记录着SharedPreferences的重要数据, 如下:

   1. sSharedPrefsCache:以包名为key, 二级key是以SP文件, 以SharedPreferencesImpl为value的嵌套map结构. 这里需要sSharedPrefsCache是静态类成员变量, 每个进程是保存唯一一份, 且由ContextImpl.class锁保护.
   2. mSharedPrefsPaths:记录所有的SP文件, 以文件名为key, 具体文件为value的map结构;
   3. mPreferencesDir:是指SP所在目录, 是指/data/data//shared_prefs/

2. SP获取方式

   1. getPreferences{Activity.getPreferences(mode): 以当前Activity的类名作为SP的文件名. 即xxxActivity.xml.}

       public SharedPreferences getPreferences(int mode) {
       //[见下文]
       return getSharedPreferences(getLocalClassName(), mode);
       }
      

   2. getDefaultSharedPreferences{PreferenceManager.getDefaultSharedPreferences(Context): 以包名加上_preferences作为文件名, 以MODE_PRIVATE模式创建SP文件. 即packgeName_preferences.xml.}

       public static SharedPreferences getDefaultSharedPreferences(Context context) {
       //[见下文]
       return context.getSharedPreferences(getDefaultSharedPreferencesName(context),
               getDefaultSharedPreferencesMode());
       }
      

   3. getSharedPreferences{当然也可以直接调用Context.getSharedPreferences(name, mode), 以上所有的方法最终都是调用到如下方法:}

      1. 此方法是contxtimpl的具体实现:

          class ContextImpl extends Context {
          private ArrayMap 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);
          }
          }
         

      2. 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);
                 }
             } 
         

      3. getSharedPreferences

            public SharedPreferences getSharedPreferences(File file, int mode) {
          checkMode(mode); //[见小节2.2.1]
          SharedPreferencesImpl sp;
          synchronized (ContextImpl.class) {
              //[见小节2.2.2]
              final ArrayMap 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;
          }
         

      4. 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");
                }
            }
            }

3. Editor
   1.Editor 该过程同样要等待awaitLoadedLocked完成, 然后创建EditorImpl对象. 而EditorImpl作为SharedPreferencesImpl的内部类,其继承于Editor类.

    public Editor edit() {
    synchronized (this) {
        awaitLoadedLocked();
    }
    return new EditorImpl(); //创建EditorImpl
    }
   

   2. EditorImpl{从这里可以看出, 这些数据修改操作仅仅是修改mModified和mClear. 直到数据提交commit或许apply过程, 才会真正的把数据更新到SharedPreferencesImpl(简称SPI). 比如设置mClear=true则会情况SPI的mMap数据.}

       public final class EditorImpl implements Editor {
       private final Map 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;
           }
       }
       }
      

4. 数据提交{这里重点来说说数据提交的两个重要方法commit()和apply().}

   1. 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;
       }
      

      2. commitToMemory

          private MemoryCommitResult commitToMemory() {
          MemoryCommitResult mcr = new MemoryCommitResult();
          synchronized (SharedPreferencesImpl.this) {
              if (mDiskWritesInFlight > 0) {
                  mMap = new HashMap(mMap);
              }
              mcr.mapToWriteToDisk = mMap;
              mDiskWritesInFlight++;
         
              //是否有监听key改变的监听者
              boolean hasListeners = mListeners.size() > 0;
              if (hasListeners) {
                  mcr.keysModified = new ArrayList();
                  mcr.listeners = new HashSet(mListeners.keySet());
              }
         
          synchronized (this) {
              //当mClear为true, 则直接清空mMap
              if (mClear) {
                  if (!mMap.isEmpty()) {
                      mcr.changesMade = true;
                      mMap.clear();
                  }
                  mClear = false;
              }
         
          for (Map.Entry 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;
          }
         

      3. 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的写入文件操作是在单线程的线程池来完成.

五.优化

1. 强烈建议不要在sp里面存储特别大的key/value, 有助于减少卡顿/anr
2. 请不要高频地使用apply, 尽可能地批量提交;commit直接在主线程操作, 更要注意了
3. 不要使用MODE_MULTI_PROCESS;
4. 高频写操作的key与高频读操作的key可以适当地拆分文件, 由于减少同步锁竞争;
5. 不要一上来就执行getSharedPreferences().edit(), 应该分成两大步骤来做, 中间可以执行其他代码,由于edit的时候包括put,set等都是阻塞方法,等加载完成之后才能执行下一个,所以当第一次执行的时候需要创建xml文件,创建完成之后需要读入内存之后才能执行edit,所以这个时候就等待了,此时可以做点其他的工作;
6. 不要连续多次edit(), 应该获取一次获取edit(),然后多次执行putxxx(), 减少内存波动; 经常看到大家喜欢封装方法, 结果就导致这种情况的出现.
7. 每次commit时会把全部的数据更新的文件, 所以整个文件是不应该过大的, 影响整体性能;

总结:

1. 获取sp的常用的方式:
   1. Activity.getPreference(mode)此方式获取到的是以当前activity为名的sp
   2. preferenceManger.getDefaultSharedPreferences(context),此方式调用的是第三种,创建的是包名加上_preferences作为文件名,
   3. Context.getSharedPreferences(name, mode)
2. commit()和apply().
   1. apply跟commit的最大区别 在于apply的写入文件操作是在单线程的线程池来完成.
   2. apply方法开始的时候, 会把awaitCommit放入QueuedWork;文件写入操作完成, 则会把相应的awaitCommit从QueuedWork中移除.
   3. apply没有返回值, commit有返回值能知道修改是否提交成功
   4. apply是将修改提交到内存，再异步提交到磁盘文件; commit是同步的提交到磁盘文件;
   5. 多并发的提交commit时，需等待正在处理的commit数据更新到磁盘文件后才会继续往下执行，从而降低效率; 而apply只是原子更新到内存，后调用apply函数会直接覆盖前面内存数据，从一定程度上提高很多效率。