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

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

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

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

    private void enqueueDiskWrite(final MemoryCommitResult mcr,
                                  final Runnable postWriteRunnable) {
        final boolean isFromSyncCommit = (postWriteRunnable == null);
        // 創(chuàng)建 Runnable 對(duì)象
        final Runnable writeToDiskRunnable = new Runnable() {
                @Override
                public void run() {
                    // 寫(xiě)到文件,這里的鎖是 mWritingToDiskLock 對(duì)象
                    synchronized (mWritingToDiskLock) {
                        writeToFile(mcr, isFromSyncCommit);
                    }
                    synchronized (mLock) {
                        mDiskWritesInFlight--;
                    }
                    // 執(zhí)行 postWriteRunnable, commit 這里為 null
                    // apply 時(shí)不為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;
            }
        }
        // 放到隊(duì)列中執(zhí)行,內(nèi)部是一個(gè) HandlerThread,按照隊(duì)列逐個(gè)執(zhí)行任務(wù)
        QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);
    }

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

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