    // 初始化
    SharedPreferencesImpl(File file, int mode) {
        // 文件
        mFile = file;
        //備份文件 .bak 結(jié)尾,看看什么時候排上作用,比如恢復(fù)數(shù)據(jù)
        mBackupFile = makeBackupFile(file);
        mMode = mode;
        mLoaded = false;
        mMap = null;
        mThrowable = null;
        // 從硬盤中讀取
        startLoadFromDisk();
    }

硬盤中讀取文件開了新線程,主要將文件中的內(nèi)容,轉(zhuǎn)換為Map

    private void loadFromDisk() {
        synchronized (mLock) {
            if (mLoaded) {
                return;
            }
            // 存在備份文件,刪除 file,為什么
            if (mBackupFile.exists()) {
                mFile.delete();
                mBackupFile.renameTo(mFile);
            }
        }
        Map<String, Object> map = null;
        StructStat stat = null;
        Throwable thrown = null;
            stat = Os.stat(mFile.getPath());
                // 讀取流
                BufferedInputStream str = null;
                try {
                    str = new BufferedInputStream(
                            new FileInputStream(mFile), 16 * 1024);
                    // 轉(zhuǎn)為 map            
                    map = (Map<String, Object>) XmlUtils.readMapXml(str);
                } catch (Exception e) {
                    Log.w(TAG, "Cannot read " + mFile.getAbsolutePath(), e);
                } finally {
                    // 關(guān)閉流
                    IoUtils.closeQuietly(str);
                }
    }

流程很簡單,就是讀取硬盤,轉(zhuǎn)換為一個 Map

apply,commit 區(qū)別

首先 apply,commit 分別是異步/同步的寫入操作,它們都會先寫入內(nèi)存中,也就是更新 Map,不同在于寫入到硬盤的時機不同

commit 先看 commit 做了什么 ,commit 方法將返回一個布爾值,表示結(jié)果

        @Override
        public boolean commit() {
            // 先提交到內(nèi)存中
            MemoryCommitResult mcr = commitToMemory();
            // 執(zhí)行硬盤中的更新
            SharedPreferencesImpl.this.enqueueDiskWrite(
                mcr, null /* sync write on this thread okay */);
            try {
                mcr.writtenToDiskLatch.await();
            } catch (InterruptedException e) {
                // 提交異常,返回 false
                return false;
            }
            // 通知監(jiān)聽
            notifyListeners(mcr);
            // 返回結(jié)果
            return mcr.writeToDiskResult;
        }

apply

        @Override
        public void apply() {
            final long startTime = System.currentTimeMillis();
            // 都是一樣的,先寫到內(nèi)存
            final MemoryCommitResult mcr = commitToMemory();
            final Runnable awaitCommit = new Runnable() {
                    @Override
                    public void run() {
                        // 
                        mcr.writtenToDiskLatch.await();
                    }
                };
            // 往 sFinishers 隊列中添加,等待執(zhí)行
            QueuedWork.addFinisher(awaitCommit);
            // 在寫完后執(zhí)行 postWriteRunnable
            Runnable postWriteRunnable = new Runnable() {
                    @Override
                    public void run() {
                        // 執(zhí)行 awaitCommit
                        awaitCommit.run();
                        // sFinishers 隊列中移除
                        QueuedWork.removeFinisher(awaitCommit);
                    }
                };
            // 寫入硬盤
            SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
        }

硬盤中是如何更新的呢

    private void enqueueDiskWrite(final MemoryCommitResult mcr,
                                  final Runnable postWriteRunnable) {
        final boolean isFromSyncCommit = (postWriteRunnable == null);
        // 創(chuàng)建 Runnable 對象
        final Runnable writeToDiskRunnable = new Runnable() {
                @Override
                public void run() {
                    // 寫到文件,這里的鎖是 mWritingToDiskLock 對象
                    synchronized (mWritingToDiskLock) {
                        writeToFile(mcr, isFromSyncCommit);
                    }
                    synchronized (mLock) {
                        mDiskWritesInFlight--;
                    }
                    // 執(zhí)行 postWriteRunnable, commit 這里為 null
                    // apply 時不為i而空
                    if (postWriteRunnable != null) {
                        postWriteRunnable.run();
                    }
                }
            };
        // Typical #commit() path with fewer allocations, doing a write on
        // the current thread.
        // 是否為同步提交
        // 根據(jù) postWriteRunnable 是否為空, commit 這里為 true
        // apply 
        if (isFromSyncCommit) {
            boolean wasEmpty = false;
            synchronized (mLock) {
                wasEmpty = mDiskWritesInFlight == 1;
            }
            if (wasEmpty) {
                writeToDiskRunnable.run();
                return;
            }
        }
        // 放到隊列中執(zhí)行,內(nèi)部是一個 HandlerThread,按照隊列逐個執(zhí)行任務(wù)
        QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);
    }

這里用隊列來放任務(wù),應(yīng)該是要應(yīng)對多個 commit 情況,這里將所有 commit 往隊列里面放,放完后就會執(zhí)行硬盤的寫,apply 也會調(diào)用到這里

   public static void queue(Runnable work, boolean shouldDelay) {
        Handler handler = getHandler();
        synchronized (sLock) {
            // 添加到 sWork 隊列中
            sWork.add(work);
            // 異步 apply 走這個
            if (shouldDelay && sCanDelay) {
                handler.sendEmptyMessageDelayed(QueuedWorkHandler.MSG_RUN, DELAY);
            } else {
            // 同步 commit 走這個
                handler.sendEmptyMessage(QueuedWorkHandler.MSG_RUN);
            }
        }
    }

apply 的硬盤寫入,需要等待 Activity.onPause() 等時機才會執(zhí)行

讀取

讀取比寫入就簡單很多了

先查看是否從硬盤加載到了內(nèi)存,沒有就先去加載
從內(nèi)存中讀取

 public String getString(String key, @Nullable String defValue) {
        synchronized (mLock) {
            // 檢查是否從硬盤加載到了內(nèi)存,沒有就先去加載
            awaitLoadedLocked();
            String v = (String)mMap.get(key);
            return v != null ? v : defValue;
        }
    }