Android源码进阶之深入理解SharedPreference原理机制-android源码分析

[[429060]]

前言

很久没有分析源码了，今天我们来分析下SharedPreferences;

大家一起来学习;

一、SharedPreferences简单使用

1、创建

第一个参数是储存的xml文件名称，第二个是打开方式，一般就用

Context.MODE_PRIVATE； 
SharedPreferences sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE); 
1.
2.

2、写入

//可以创建一个新的SharedPreference来对储存的文件进行操作 
SharedPreferences sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE); 
//像SharedPreference中写入数据需要使用Editor 
SharedPreference.Editor editor = sp.edit(); 
//类似键值对 
editor.putString("name", "string"); 
editor.putInt("age", 0); 
editor.putBoolean("read", true); 
//editor.apply(); 
editor.commit(); 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

apply和commit都是提交保存，区别在于apply是异步执行的，不需要等待。不论删除，修改，增加都必须调用apply或者commit提交保存;
关于更新：如果已经插入的key已经存在。那么将更新原来的key;
应用程序一旦卸载，SharedPreference也会被删除;

3、读取

SharedPreference sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE); 
//第一个参数是键名，第二个是默认值 
String name=sp.getString("name", "暂无"); 
int age=sp.getInt("age", 0); 
boolean read=sp.getBoolean("isRead", false); 
1.
2.
3.
4.
5.

4、检索

SharedPreferences sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE); 
//检查当前键是否存在 
boolean isContains=sp.contains("key"); 
//使用getAll可以返回所有可用的键值 
//Map<String,?> allMaps=sp.getAll(); 
1.
2.
3.
4.
5.

5、删除

当我们要清除SharedPreferences中的数据的时候一定要先clear()、再commit()，不能直接删除xml文件;

SharedPreference sp=getSharedPreferences("名称", Context.MODE_PRIVATE); 
SharedPrefence.Editor editor=sp.edit(); 
editor.clear(); 
editor.commit(); 
1.
2.
3.
4.

getSharedPreference() 不会生成文件，这个大家都知道;
删除掉文件后，再次执行commit()，删除的文件会重生，重生文件的数据和删除之前的数据相同;
删除掉文件后，程序在没有完全退出停止运行的情况下，Preferences对象所存储的内容是不变的，虽然文件没有了，但数据依然存在;程序完全退出停止之后，数据才会丢失;
清除SharedPreferences数据一定要执行editor.clear()，editor.commit()，不能只是简单的删除文件，这也就是最后的结论，需要注意的地方

二、SharedPreferences源码分析

1、创建

SharedPreferences preferences = getSharedPreferences("test", Context.MODE_PRIVATE); 
1.

实际上context的真正实现类是ContextImp，所以进入到ContextImp的getSharedPreferences方法查看：

@Override 
   public SharedPreferences getSharedPreferences(String name, int mode) { 
       ...... 
       File file; 
       synchronized (ContextImpl.class) { 
           if (mSharedPrefsPaths == null) { 
           //定义类型：ArrayMap<String, File> mSharedPrefsPaths; 
               mSharedPrefsPaths = new ArrayMap<>(); 
           } 
           //从mSharedPrefsPaths中是否能够得到file文件 
           file = mSharedPrefsPaths.get(name); 
           if (file == null) {//如果文件为null 
           //就创建file文件 
               file = getSharedPreferencesPath(name); 
               将name，file键值对存入集合中 
               mSharedPrefsPaths.put(name, file); 
           } 
       } 
       return getSharedPreferences(file, mode); 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

ArrayMap<String, File> mSharedPrefsPaths;对象是用来存储SharedPreference文件名称和对应的路径，获取路径是在下列方法中，就是获取data/data/包名/shared_prefs/目录下的

@Override 
public File getSharedPreferencesPath(String name) { 
    return makeFilename(getPreferencesDir(), name + ".xml"); 
} 
private File getPreferencesDir() { 
        synchronized (mSync) { 
            if (mPreferencesDir == null) { 
                mPreferencesDir = new File(getDataDir(), "shared_prefs"); 
            } 
            return ensurePrivateDirExists(mPreferencesDir); 
        } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

路径之后才开始创建对象

@Override 
  public SharedPreferences getSharedPreferences(File file, int mode) { 
  //重点1 
      checkMode(mode); 
  ....... 
      SharedPreferencesImpl sp; 
      synchronized (ContextImpl.class) { 
      //获取缓存对象（或者创建缓存对象） 
          final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked(); 
          //通过键file从缓存对象中获取Sp对象 
          sp = cache.get(file); 
          //如果是null，就说明缓存中还没后该文件的sp对象 
          if (sp == null) { 
          //重点2：从磁盘读取文件 
              sp = new SharedPreferencesImpl(file, mode); 
              //添加到内存中 
              cache.put(file, sp); 
              //返回sp 
              return sp; 
          } 
      } 
      //如果设置为MODE_MULTI_PROCESS模式，那么将执行SP的startReloadIfChangedUnexpectedly方法。 
      if ((mode & Context.MODE_MULTI_PROCESS) != 0 || 
          getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) { 
          sp.startReloadIfChangedUnexpectedly(); 
      } 
      return sp; 
  } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

就是重载之前的方法，只是入参由文件名改为File了，给创建过程加锁了synchronized ，通过方法getSharedPreferencesCacheLocked()获取系统中存储的所有包名以及对应的文件，这就是每个sp文件只有一个对应的SharedPreferencesImpl实现对象原因

流程：

获取缓存区，从缓存区中获取数据，看是否存在sp对象，如果存在就直接返回
如果不存在，那么就从磁盘获取数据，
从磁盘获取的数据之后，添加到内存中，
返回sp;

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; 
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

getSharedPreferences(File file, int mode)方法中，从上面的系统缓存中分局File获取SharedPreferencesImpl对象，如果之前没有使用过，就需要创建一个对象了，通过方法checkMode(mode);
先检查mode是否是三种模式，然后通过sp = new SharedPreferencesImpl(file, mode);
创建对象，并将创建的对象放到系统的packagePrefs中，方便以后直接获取;

SharedPreferencesImpl(File file, int mode) { 
        mFile = file; //存储文件 
        //备份文件（灾备文件） 
        mBackupFile = makeBackupFile(file); 
        //模式 
        mMode = mode; 
        //是否加载过了 
        mLoaded = false; 
        // 存储文件内的键值对信息 
        mMap = null; 
        //从名字可以知道是：开始加载数据从磁盘 
        startLoadFromDisk(); 
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

主要是设置了几个参数，mFile 是原始文件;mBackupFile 是后缀.bak的备份文件;
mLoaded标识是否正在加载修改文件;
mMap用来存储sp文件中的数据，存储时候也是键值对形式，获取时候也是通过这个获取，这就是表示每次使用sp的时候，都是将数据写入内存，也就是sp数据存储数据快的原因，所以sp文件不能存储大量数据，否则执行时候很容易会导致OOM;
mThrowable加载文件时候报的错误;
下面就是加载数据的方法startLoadFromDisk();从sp文件中加载数据到mMap中

2、startLoadFromDisk()

private void startLoadFromDisk() { 
       synchronized (mLock) { 
           mLoaded = false; 
       } 
       //开启子线程加载磁盘数据 
       new Thread("SharedPreferencesImpl-load") { 
           public void run() { 
               loadFromDisk(); 
           } 
       }.start(); 
   } 
   private void loadFromDisk() { 
       synchronized (mLock) { 
       //如果加载过了 直接返回 
           if (mLoaded) { 
               return; 
           } 
           //备份文件是否存在， 
           if (mBackupFile.exists()) { 
           //删除file原文件 
               mFile.delete(); 
               //将备份文件命名为：xml文件 
               mBackupFile.renameTo(mFile); 
           } 
       } 
       ....... 
       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); 
                   map = XmlUtils.readMapXml(str); 
               } catch (Exception e) { 
                   Log.w(TAG, "Cannot read " + mFile.getAbsolutePath(), e); 
               } finally { 
                   IoUtils.closeQuietly(str); 
               } 
           } 
       } catch (ErrnoException e) { 
           /* ignore */ 
       } 
       synchronized (mLock) { 
       //已经加载完毕， 
           mLoaded = true; 
           //数据不是null 
           if (map != null) { 
           //将map赋值给全局的存储文件键值对的mMap对象 
               mMap = map; 
               //更新内存的修改时间以及文件大小 
               mStatTimestamp = stat.st_mtime; 
               mStatSize = stat.st_size; 
           } else { 
               mMap = new HashMap<>(); 
           } 
           //重点：唤醒所有以mLock锁的等待线程 
           mLock.notifyAll(); 
       } 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.

首先判断备份文件是否存在，如果存在，就更该备份文件的后缀名;接着就开始读取数据，然后将读取的数据赋值给全局变量存储文件键值对的mMap对象，并且更新修改时间以及文件大小变量;
唤醒所有以mLock为锁的等待线程;
到此为止，初始化SP对象就算完成了，其实可以看出来就是一个二级缓存流程：磁盘到内存;

3、get获取SP中的键值对

@Nullable 
   public String getString(String key, @Nullable String defValue) { 
       synchronized (mLock) { 锁判断 
           awaitLoadedLocked(); //等待机制 
           String v = (String)mMap.get(key); //从键值对中获取数据 
           return v != null ? v : defValue; 
       } 
   } 
private void awaitLoadedLocked() { 
       ....... 
       while (!mLoaded) { //在加载数据完毕的时候，值为true 
           try { 
           //线程等待 
               mLock.wait(); 
           } catch (InterruptedException unused) { 
           } 
       } 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

如果数据没有加载完毕(也就是说mLoaded=false)，此时将线程等待;

4、putXXX以及apply源码

public Editor edit() { 
        //跟getXXX原理一样 
        synchronized (mLock) { 
            awaitLoadedLocked(); 
        } 
        //返回EditorImp对象 
        return new EditorImpl(); 
    } 
 public Editor putBoolean(String key, boolean value) { 
      synchronized (mLock) { 
           mModified.put(key, value); 
           return this; 
         } 
 } 
       public void apply() { 
            final long startTime = System.currentTimeMillis(); 
            //根据名字可以知道：提交数据到内存 
            final MemoryCommitResult mcr = commitToMemory(); 
           ........ 
//提交数据到磁盘中 
            SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable); 
            //重点：调用listener 
            notifyListeners(mcr); 
        } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

先执行了commitToMemory，提交数据到内存;然后提交数据到磁盘中;
紧接着调用了listener;

5、commitToMemory

     private MemoryCommitResult commitToMemory() { 
            long memoryStateGeneration; 
            List<String> keysModified = null; 
            Set<OnSharedPreferenceChangeListener> listeners = null; 
            //写到磁盘的数据集合 
            Map<String, Object> mapToWriteToDisk; 
            synchronized (SharedPreferencesImpl.this.mLock) { 
                if (mDiskWritesInFlight > 0) { 
                    mMap = new HashMap<String, Object>(mMap); 
                } 
                //赋值此时缓存集合给mapToWriteToDisk  
                mapToWriteToDisk = mMap; 
                ....... 
                synchronized (mLock) { 
                    boolean changesMade = false; 
                    //重点：是否清空数据 
                    if (mClear) { 
                        if (!mMap.isEmpty()) { 
                            changesMade = true; 
                            //清空缓存中键值对信息 
                            mMap.clear(); 
                        } 
                        mClear = false; 
                    } 
                    //循环mModified，将mModified中的数据更新到mMap中 
                    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); 
                        } 
......... 
                    } 
                    //清空临时集合 
                    mModified.clear(); 
                   ...... 
                } 
            } 
            return new MemoryCommitResult(memoryStateGeneration, keysModified, listeners, 
                    mapToWriteToDisk); 
        } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.

mModified就是我们本次要更新添加的键值对集合;
mClear是我们调用clear()方法的时候赋值的;
大致流程就是：首先判断是否需要清空内存数据，然后循环mModified集合，添加更新数据到内存的键值对集合中;

6、commit方法

public boolean commit() { 
           ....... 
           //更新数据到内存 
           MemoryCommitResult mcr = commitToMemory(); 
           //更新数据到磁盘 
           SharedPreferencesImpl.this.enqueueDiskWrite( 
               mcr, null /* sync write on this thread okay */); 
           try { 
           //等待：等待磁盘更新数据完成 
               mcr.writtenToDiskLatch.await(); 
           } catch (InterruptedException e) { 
               return false; 
           } finally { 
               if (DEBUG) { 
                   Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration 
                           + " committed after " + (System.currentTimeMillis() - startTime) 
                           + " ms"); 
               } 
           } 
           //执行listener回调 
           notifyListeners(mcr); 
           return mcr.writeToDiskResult; 
       } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

首先apply没有返回值，commit有返回值;
其实apply执行回调是和数据写入磁盘并行执行的，而commit方法执行回调是等待磁盘写入数据完成之后;

三、QueuedWork详解

1、QueuedWork

QueuedWork这个类，因为sp的初始化之后就是使用，前面看到，无论是apply还是commit方法都是通过QueuedWork来实现的;

QueuedWork是一个管理类，顾名思义，其中有一个队列，对所有入队的work进行管理调度;

其中最重要的就是有一个HandlerThread

private static Handler getHandler() { 
       synchronized (sLock) { 
           if (sHandler == null) { 
               HandlerThread handlerThread = new HandlerThread("queued-work-looper", 
                       Process.THREAD_PRIORITY_FOREGROUND); 
               handlerThread.start(); 
               sHandler = new QueuedWorkHandler(handlerThread.getLooper()); 
           } 
           return sHandler; 
       } 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

2、入队queue

// 如果是commit，则不能delay，如果是apply，则可以delay 
   public static void queue(Runnable work, boolean shouldDelay) { 
       Handler handler = getHandler(); 
       synchronized (sLock) { 
           sWork.add(work); 
           if (shouldDelay && sCanDelay) { 
               // 默认delay的时间是100ms 
               handler.sendEmptyMessageDelayed(QueuedWorkHandler.MSG_RUN, DELAY); 
           } else { 
               handler.sendEmptyMessage(QueuedWorkHandler.MSG_RUN); 
           } 
       } 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

3、消息的处理

private static class QueuedWorkHandler extends Handler { 
       static final int MSG_RUN = 1; 
       QueuedWorkHandler(Looper looper) { 
           super(looper); 
       } 
       public void handleMessage(Message msg) { 
           if (msg.what == MSG_RUN) { 
               processPendingWork(); 
           } 
       } 
   } 
   private static void processPendingWork() { 
       synchronized (sProcessingWork) { 
           LinkedList<Runnable> work; 
           synchronized (sLock) { 
               work = (LinkedList<Runnable>) sWork.clone(); 
               sWork.clear(); 
               getHandler().removeMessages(QueuedWorkHandler.MSG_RUN); 
           } 
           if (work.size() > 0) { 
               for (Runnable w : work) { 
                   w.run(); 
               } 
           } 
       } 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

可以看到，调度非常简单，内部有一个sWork，需要执行的时候遍历所有的runnable执行;
对于apply操作，会有一定的延迟再去执行work，但是对于commit操作，则会马上触发调度，而且并不仅仅是调度commit传过来的那个任务，而是马上就调度队列中所有的work;

4、waitToFinish

系统中很多地方会等待sp的写入文件完成，等待方式是通过调用QueuedWork.waitToFinish();

public static void waitToFinish() { 
      Handler handler = getHandler(); 
      synchronized (sLock) { 
          // 移除所有消息，直接开始调度所有work 
          if (handler.hasMessages(QueuedWorkHandler.MSG_RUN)) { 
              handler.removeMessages(QueuedWorkHandler.MSG_RUN); 
          } 
          sCanDelay = false; 
      } 
      StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites(); 
      try { 
          // 如果是waitToFinish调用过来，则马上执行所有的work 
          processPendingWork(); 
      } finally { 
          StrictMode.setThreadPolicy(oldPolicy); 
      } 
      try { 
          // 在所有的work执行完毕之后，还需要执行Finisher 
          // 前面在apply的时候有一步是QueuedWork.addFinisher(awaitCommit); 
          // 其中的实现是等待sp文件的写入完成 
          // 如果没有通过msg去调度而是通过waitToFinish，则那个runnable就会在这里被执行 
          while (true) { 
              Runnable finisher; 
              synchronized (sLock) { 
                  finisher = sFinishers.poll(); 
              } 
              if (finisher == null) { 
                  break; 
              } 
              finisher.run(); 
          } 
      } finally { 
          sCanDelay = true; 
      } 
      ... 
  } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.

系统中对于四大组件的处理逻辑都在ActivityThread中实现，在service/activity的生命周期的执行中都会等待sp的写入完成，正是通过调用QueuedWork.waitToFinish()，确保app的数据正确的写入到disk;

5、sp使用的建议

对数据实时性要求不高，尽量使用apply
如果业务要求必须数据成功写入，使用commit
减少sp操作频次，尽量一次commit把所有的数据都写入完毕
可以适当考虑不要在主线程访问sp
写入sp的数据尽量轻量级

总结：

SharedPreferences的本身实现就是分为两步，一步是内存，一部是磁盘，而主线程又依赖SharedPreferences的写入，所以可能当io成为瓶颈的时候，App会因为SharedPreferences变的卡顿，严重情况下会ANR，总结下来有以下几点：

存放在xml文件中的数据会被装在到内存中，所以获取数据很快
apply是异步操作，提交数据到内存，并不会马上提交到磁盘
commit是同步操作，会等待数据写入到磁盘，并返回结果
如果有同一个线程多次commit，则后面的要等待前面执行结束
如果多个线程对同一个sp并发commit，后面的所有任务会进入到QueuedWork中排队执行，且都要等第一个执行完毕

本文转载自微信公众号「Android开发编程」

【编辑推荐】