SharedPreferences解析

// 加载SP文件数据,“my_prefs”为文件名SharedPreferences sp = getSharedPreferences("my_prefs", Context.MODE_PRIVATE);
// 保存数据SharedPreferences.Editor editor = sp.edit();editor.putString("blog", "www.xucanhui.com");// 提交数据：同步方式，有返回值表示数据保存是否成功boolean result = editor.commit(); // 提交数据：异步方式，没有返回值// editor.apply()
// 读取数据String blog = sp.getString("blog", "");

<?xml version='1.0' encoding='utf-8' standalone='yes' ?><map>    <string name="blog">www.xucanhui.com</string></map>

class ContextImpl extends Context {
    @GuardedBy("ContextImpl.class")    private ArrayMap<String, File> mSharedPrefsPaths;
    // ...
    @Override    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) {                // 如果文件不存在，则创建新的文件                file = getSharedPreferencesPath(name);                // 将新创建的文件保存到mSharedPrefsPaths，以文件名为key                mSharedPrefsPaths.put(name, file);            }        }        return getSharedPreferences(file, mode);    }
    @Override    public File getSharedPreferencesPath(String name) {        return makeFilename(getPreferencesDir(), name + ".xml");    }
    private File getPreferencesDir() {        synchronized (mSync) {            if (mPreferencesDir == null) {                // 创建目录/data/data/<packageName>/shared_prefs/                mPreferencesDir = new File(getDataDir(), "shared_prefs");            }            return ensurePrivateDirExists(mPreferencesDir);        }    }}

@Overridepublic SharedPreferences getSharedPreferences(File file, int mode) {    SharedPreferencesImpl sp;    synchronized (ContextImpl.class) {        final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();        sp = cache.get(file);        if (sp == null) {            checkMode(mode);            if (getApplicationInfo().targetSdkVersion >= android.os.Build.VERSION_CODES.O) {                if (isCredentialProtectedStorage()                    && !getSystemService(UserManager.class)                    .isUserUnlockingOrUnlocked(UserHandle.myUserId())) {                    throw new IllegalStateException("SharedPreferences in credential encrypted "                                                    + "storage are not available until after user is unlocked");                }            }            // 创建SharedPreferencesImpl            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) {        // 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;}
@GuardedBy("ContextImpl.class")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;}

SharedPreferencesImpl(File file, int mode) {    mFile = file;    // 创建.bak后缀的备份文件，用于在发生异常时，可以通过备份文件来恢复数据    mBackupFile = makeBackupFile(file);    mMode = mode;    mLoaded = false;    mMap = null;    mThrowable = null;    startLoadFromDisk();}

private void startLoadFromDisk() {    synchronized (mLock) {        mLoaded = false;    }    // 通过工作线程读取文件数据到mMap    new Thread("SharedPreferencesImpl-load") {        public void run() {            loadFromDisk();        }    }.start();}
private void loadFromDisk() {    synchronized (mLock) {        if (mLoaded) {            return;        }        if (mBackupFile.exists()) {            mFile.delete();            mBackupFile.renameTo(mFile);        }    }
    // Debugging    if (mFile.exists() && !mFile.canRead()) {        Log.w(TAG, "Attempt to read preferences file " + mFile + " without permission");    }
    Map<String, Object> map = null;    StructStat stat = null;    Throwable thrown = null;    try {        stat = Os.stat(mFile.getPath());        if (mFile.canRead()) {            BufferedInputStream str = null;            try {                str = new BufferedInputStream(                    new FileInputStream(mFile), 16 * 1024);                map = (Map<String, Object>) XmlUtils.readMapXml(str);            } catch (Exception e) {                Log.w(TAG, "Cannot read " + mFile.getAbsolutePath(), e);            } finally {                IoUtils.closeQuietly(str);            }        }    } catch (ErrnoException e) {        // An errno exception means the stat failed. Treat as empty/non-existing by        // ignoring.    } catch (Throwable t) {        thrown = t;    }
    synchronized (mLock) {        mLoaded = true;        mThrowable = thrown;
        // It's important that we always signal waiters, even if we'll make        // them fail with an exception. The try-finally is pretty wide, but        // better safe than sorry.        try {            if (thrown == null) {                if (map != null) {                    mMap = map;                    mStatTimestamp = stat.st_mtim;                    mStatSize = stat.st_size;                } else {                    mMap = new HashMap<>();                }            }            // In case of a thrown exception, we retain the old map. That allows            // any open editors to commit and store updates.        } catch (Throwable t) {            mThrowable = t;        } finally {            mLock.notifyAll();        }    }}

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() {    if (!mLoaded) {        BlockGuard.getThreadPolicy().onReadFromDisk();    }    while (!mLoaded) {        try {            // 当没有加载完成，则进入等待状态            mLock.wait();        } catch (InterruptedException unused) {        }    }    if (mThrowable != null) {        throw new IllegalStateException(mThrowable);    }}

public Editor edit() {    synchronized (mLock) {        // 等待数据加载完成        awaitLoadedLocked();    }    // 创建EditorImpl实例    return new EditorImpl();}

public final class EditorImpl implements Editor {
    @GuardedBy("mEditorLock")    private final Map<String, Object> mModified = new HashMap<>();
    @GuardedBy("mEditorLock")    private boolean mClear = false;
    // ...
    // 插入数据    public Editor putString(String key, @Nullable String value) {        synchronized (mEditorLock) {            // 插入数据，暂存到mModified            mModified.put(key, value);            return this;        }    }
    // 移除数据    public Editor remove(String key) {        synchronized (mEditorLock) {            mModified.put(key, this);            return this;        }    }
    // 清空全部数据    public Editor clear() {        synchronized (mEditorLock) {            mClear = true;            return this;        }    }}

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;    }    // 通知监听器，并在主线程回调onSharedPreferenceChanged()方法    notifyListeners(mcr);    // 返回文件操作的结果    return mcr.writeToDiskResult;}

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 = mMap;        mDiskWritesInFlight++;
        boolean hasListeners = mListeners.size() > 0;        if (hasListeners) {            keysModified = new ArrayList<String>();            listeners = new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());        }
        synchronized (mEditorLock) {            boolean changesMade = false;            // 当mClear为true，则直接清空mMap            if (mClear) {                if (!mapToWriteToDisk.isEmpty()) {                    changesMade = true;                    mapToWriteToDisk.clear();                }                mClear = false;            }
            for (Map.Entry<String, Object> e : mModified.entrySet()) {                String k = e.getKey();                Object v = e.getValue();                   // this是一个特殊值，当v为空，相当于remove该条数据                if (v == this || v == null) {                    if (!mapToWriteToDisk.containsKey(k)) {                        continue;                    }                    mapToWriteToDisk.remove(k);                } else {                    if (mapToWriteToDisk.containsKey(k)) {                        Object existingValue = mapToWriteToDisk.get(k);                        if (existingValue != null && existingValue.equals(v)) {                            continue;                        }                    }                    mapToWriteToDisk.put(k, v);                }                // 表示数据有改变                changesMade = true;                if (hasListeners) {                    keysModified.add(k);                }            }            // 清空mModified的数据            mModified.clear();
            if (changesMade) {                mCurrentMemoryStateGeneration++;            }
            memoryStateGeneration = mCurrentMemoryStateGeneration;        }    }    return new MemoryCommitResult(memoryStateGeneration, keysModified, listeners,                                  mapToWriteToDisk);}

private void enqueueDiskWrite(final MemoryCommitResult mcr,                              final Runnable postWriteRunnable) {    final boolean isFromSyncCommit = (postWriteRunnable == null);
    final Runnable writeToDiskRunnable = new Runnable() {        @Override        public void run() {            synchronized (mWritingToDiskLock) {                // 执行文件写入操作                writeToFile(mcr, isFromSyncCommit);            }            synchronized (mLock) {                mDiskWritesInFlight--;            }            if (postWriteRunnable != null) {                postWriteRunnable.run();            }        }    };
    // 使用commit方法，会进入这个分支，在当前线程执行    if (isFromSyncCommit) {        boolean wasEmpty = false;        synchronized (mLock) {            wasEmpty = mDiskWritesInFlight == 1;        }        if (wasEmpty) {            writeToDiskRunnable.run();            return;        }    }
    // 使用apply方法，会执行该句，将任务放入单线程的线程池中执行    QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);}

private void writeToFile(MemoryCommitResult mcr, boolean isFromSyncCommit) {    // ...
    boolean fileExists = mFile.exists();
    if (fileExists) {        boolean needsWrite = false;
        // Only need to write if the disk state is older than this commit        if (mDiskStateGeneration < mcr.memoryStateGeneration) {            if (isFromSyncCommit) {                needsWrite = true;            } else {                synchronized (mLock) {                    // No need to persist intermediate states. Just wait for the latest state to                    // be persisted.                    if (mCurrentMemoryStateGeneration == mcr.memoryStateGeneration) {                        needsWrite = true;                    }                }            }        }
        // 没有改变，直接返回        if (!needsWrite) {            mcr.setDiskWriteResult(false, true);            return;        }
        boolean backupFileExists = mBackupFile.exists();        if (!backupFileExists) {            // 当备份文件不存在，则把mFile重命名为备份文件            if (!mFile.renameTo(mBackupFile)) {                Log.e(TAG, "Couldn't rename file " + mFile                      + " to backup file " + mBackupFile);                mcr.setDiskWriteResult(false, false);                return;            }        } else {            // 否则，直接删除mFile            mFile.delete();        }    }
    try {        FileOutputStream str = createFileOutputStream(mFile);
        if (str == null) {            mcr.setDiskWriteResult(false, false);            return;        }        // 将mMap全部信息写入文件        XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);
        writeTime = System.currentTimeMillis();
        FileUtils.sync(str);
        fsyncTime = System.currentTimeMillis();
        str.close();        ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0);
        try {            final StructStat stat = Os.stat(mFile.getPath());            synchronized (mLock) {                mStatTimestamp = stat.st_mtim;                mStatSize = stat.st_size;            }        } catch (ErrnoException e) {            // Do nothing        }
        if (DEBUG) {            fstatTime = System.currentTimeMillis();        }
        // 写入成功，删除备份文件        mBackupFile.delete();
        mDiskStateGeneration = mcr.memoryStateGeneration;
        // 返回写入成功，唤醒等待线程        mcr.setDiskWriteResult(true, true);
        return;    } catch (XmlPullParserException e) {        Log.w(TAG, "writeToFile: Got exception:", e);    } catch (IOException e) {        Log.w(TAG, "writeToFile: Got exception:", e);    }
    // 如果文件写入操作失败，则删除未成功写入的文件    if (mFile.exists()) {        if (!mFile.delete()) {            Log.e(TAG, "Couldn't clean up partially-written file " + mFile);        }    }    // 返回写入失败，唤醒等待线程    mcr.setDiskWriteResult(false, false);}

public void apply() {    final long startTime = System.currentTimeMillis();
    // 把数据更新到内存    final MemoryCommitResult mcr = commitToMemory();    final Runnable awaitCommit = new Runnable() {        @Override        public void run() {            try {                // 进入等待状态                mcr.writtenToDiskLatch.await();            } catch (InterruptedException ignored) {            }        }    };
    QueuedWork.addFinisher(awaitCommit);
    Runnable postWriteRunnable = new Runnable() {        @Override        public void run() {            awaitCommit.run();            QueuedWork.removeFinisher(awaitCommit);        }    };
    // 将数据以异步的方式写入文件    SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
    notifyListeners(mcr);}