SharedPreference源码解析

概要：

    SharedPreference属于轻量级的键值存储方式，以xml文件保存。作为Android存储数据的

一个重要的方式，值得透彻分析一下。

SharedPreference的获取方式：

 首先SharedPreference的获取方式，有两种Activity的getSharedPreference(int mode)与Context的

getSharedPreference（String name, int mode）;

先看Activity的getSharedPreference（int mode）：

public SharedPreferences getPreferences(@Context.PreferencesMode int mode) {
//getLocalClassName 就是Activity的类名
    return getSharedPreferences(getLocalClassName(), mode);
}

@Override
public SharedPreferences getSharedPreferences(String name, int mode) {
    return mBase.getSharedPreferences(name, mode);//mBase是Context实例
}

所以最后还是调用了Context.getSharedPreference(String name, int mode),但是Context是抽象类，

它的的实现是ContextImp（这涉及到Activity的启动过程，不在这里赘述了）。

 现在我们来看一下ContextImp的getSharedPreference（String name， int mode）（为了方便展示

我会去掉一些多余的代码）

@Override
public SharedPreferences getSharedPreferences(String name, int mode) {
        File file;
        synchronized (ContextImpl.class) {
            if (mSharedPrefsPaths == null) {
                mSharedPrefsPaths = new ArrayMap<>();
            }
            file = mSharedPrefsPaths.get(name);
            if (file == null) {
                file = getSharedPreferencesPath(name);//创建file
                mSharedPrefsPaths.put(name, file);
            }
        }
        return getSharedPreferences(file, mode);//获取SharedPreference。
    }

这里会先根据name判断相应的File是否存在，如果不存在就利用getSharedPreferencesPath(name)创建一个新

的File，然后再回调getSharedPreferences（File file, int mode）。

其中创建File的函数：getSharedPreferencesPath(name):

    @Override
    public File getSharedPreferencesPath(String name) {
        return makeFilename(getPreferencesDir(), name + ".xml");//getPreferencesDir父目录的确认
    }

    private File makeFilename(File base, String name) {
        if (name.indexOf(File.separatorChar) < 0) {
            return new File(base, name);
        }
    }

其中getPreferencesDir的确认涉及到了PackageInfo的datadir,和process.myUid();

 我们继续看getSharedPreference(File file,int mode);

    @Override
    public SharedPreferences getSharedPreferences(File file, int mode) {
        checkMode(mode);
        SharedPreferencesImpl sp;
        synchronized (ContextImpl.class) {
            final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
            sp = cache.get(file);
            if (sp == null) {
                sp = new SharedPreferencesImpl(file, mode);
                cache.put(file, sp);
                return sp;
            }
        }
        return sp;
    }

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

我们先拿到ArrayMap<File, SharedPreferencesImp>类型的map，再从map中检查，没有则重新创建

其中SharedPreferencesImp就是SharedPreference的实现类。

  最后我们查看SharedPreferencesImp类：

   final class SharedPreferencesImpl implements SharedPreferences {
       SharedPreferencesImpl(File file, int mode) {
           mFile = file;
           mBackupFile = makeBackupFile(file);
           mMode = mode;
           mLoaded = false;
           mMap = null;
           startLoadFromDisk();//加载数据
   }

   private void startLoadFromDisk() {
        synchronized (mLock) {
            mLoaded = false;
        }
        new Thread("SharedPreferencesImpl-load") {
            public void run() {
                 loadFromDisk();
            }
        }.start();
   }
}

可以看到，SharedPreferencesImp的构造中，开启线程去加载文件xml的数据。

  总结：SharedPreference获取的实例是一个单例，且在创建的时候开线程去解析加载文件数据。

SharedPreference.edit()获取Editor。

    public Editor edit() {
        synchronized (mLock) {
            awaitLoadedLocked();
        }

        return new EditorImpl();
    }

可以看到返回了一个Editor的实现类EditorImpl，但是前面有个方法awaitLoadedLocked()方法，采用的

是await和notify，处理并发，实现逻辑:loadFromDisk数据加载完成前，awaitLoadedLocked处于阻塞状态。

Editor.putxxxx方法，这里举例putString(String key, String value)

    public Editor putString(String key, @Nullable String value) {
        synchronized (mLock) {
            mModified.put(key, value);
            return this;
        }
    }

很简单，就是将数据放到内存中。

Editor.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 {
        }
        notifyListeners(mcr);
        return mcr.writeToDiskResult;
   }

真正重要的方法就两个commitToMemory将改变数据和原先的数据整理在一起（Map中，待写入数据），

封装到MemoryCommitResult，然后enqueueDiskWrite正式写到磁盘。

     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 = mMap;
                synchronized (mLock) {//整合数据
                    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();
                 }
         }//封装到MemoryCommitResultzhong
         return new MemoryCommitResult(memoryStateGeneration, keysModified, listeners,
                 mapToWriteToDisk);
     }

enqueueDiskWrite：

    private void enqueueDiskWrite(final MemoryCommitResult mcr,
                                  final Runnable postWriteRunnable) {
        final boolean isFromSyncCommit = (postWriteRunnable == null);

        final Runnable writeToDiskRunnable = new Runnable() {
                public void run() {
                    synchronized (mWritingToDiskLock) {
                        writeToFile(mcr, isFromSyncCommit);
                    }
                    synchronized (mLock) {
                        mDiskWritesInFlight--;
                    }
                    if (postWriteRunnable != null) {
                        postWriteRunnable.run();
                    }
                }
            };
        if (isFromSyncCommit) {
            synchronized (mLock) {
                wasEmpty = mDiskWritesInFlight == 1;
            }
            if (wasEmpty) {
                writeToDiskRunnable.run();//关键点，说明是同步进行的，在主线调用，在主线执行。
                return;
            }
        }

       QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);//apply(),则是放在任务队列中，异步执行
    }

    private void writeToFile(MemoryCommitResult mcr, boolean isFromSyncCommit) {
        try {此方法最重要的函数，调用XmlUtils写入操作。
            XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);
        } catch (XmlPullParserException e) {
            Log.w(TAG, "writeToFile: Got exception:", e);
        } catch (IOException e) {
            Log.w(TAG, "writeToFile: Got exception:", e);
        }
    }

Eidtor.apply()

与Commit类似，只是它是异步的。在最后一步将任务放在任务队列中，多个任务线性一次执行。

又因为SharePreferenceImp单例原因，使用apply异步操作也是安全操作。推荐使用。