Android存储之SharedPreferences源码解析

SharedPreferences sp = getSharedPreferences("haichenyi", MODE_PRIVATE);

private void awaitLoadedLocked() {
    ...
    //while循环，当mLoaded为false的时候进入while
    while (!mLoaded) {
        try {
            //wait方法
            mLock.wait();
        } catch (InterruptedException unused) {
        }
    }
    ...
}

private void loadFromDisk() {
    ...
    //开始从文件读取数据
    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 = (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的值
        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
                    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
            mLock.notifyAll();
        }
    }
}

//这里是直接返回对象，
//但是，它实际上数据量大的时候，是需要时间去从磁盘读数据的
SharedPreferences sp = getSharedPreferences("haichenyi", MODE_PRIVATE);
//当代码执行到这里的时候，我们虽然，拿到了sp对象，
//但是，数据可能没有读取完，上面说的boolean的值，还是false，
//就进入while循环，调用awit方法，进入等待状态
//然后，过一会从磁盘读取完数据，修改boolean值为true，在finally调用notifyAll唤醒mLock
//然后，唤醒了while循环，boolean的值这个时候是true，跳出while循环
//所以，这个卡顿的时间，就是从磁盘读取数据的时间
String s = sp.getString("xxx","aaa");

//看到这个方法有返回值就知道了，boolean类型的返回值
public boolean commit() {
        ...
        //为什么说每次都是全量更新，就在这里，这个commitToMemory方法里面，
        //它每次都会把内存的map数据全部都更新好
        MemoryCommitResult mcr = commitToMemory();
        //然后通过这个enqueueDisk方法全部都重新写到硬盘上
        //第二个参数是null，它的注释也比较清楚
        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;
    }

//这个方法没有返回值
public void apply() {
        ...
    }

public void apply() {
    final long startTime = System.currentTimeMillis();
    final MemoryCommitResult mcr = commitToMemory();
    //重点就是这里，它这里是新建了一个runnable来执行await方法，
    //上面commit方法是直接在当前线程执行的
    final Runnable awaitCommit = new Runnable() {
        @Override
        public void run() {
            try {
                mcr.writtenToDiskLatch.await();
            } catch (InterruptedException ignored) {
            }
            ...
        }
    };
    //然后调用了QueuedWork.addFinisher,把这个runnable传了进去
    //这个QueuedWork是什么呢？下面我贴出来了这个方法，addFinisher
    QueuedWork.addFinisher(awaitCommit);
    //上面其实就是把runnable加到了一个队列当中
    
    //又新开了一个runnable执行了上面runnable的run方法，
    //这是什么意思还要我做过多的解释吗？runnable.run()
    Runnable postWriteRunnable = new Runnable() {
        @Override
        public void run() {
            awaitCommit.run();
            QueuedWork.removeFinisher(awaitCommit);
        }
    };
    //回过头看看，commit的这个方法，第二个参数是null，上面我特意做了解释的。
    //看这里，第二个参数，传的runnable
    //就是在runnable的线程里面执行
    SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);

    // Okay to notify the listeners before it's hit disk
    // because the listeners should always get the same
    // SharedPreferences instance back, which has the
    // changes reflected in memory.
    notifyListeners(mcr);
}


@UnsupportedAppUsage
public static void addFinisher(Runnable finisher) {
    synchronized (sLock) {
        //等于，就是把我们的runnable给add到了sFinishers，这个sFinishers又是什么呢？
        sFinishers.add(finisher);
    }
}
//没错，它其实就是一个队列，再回到上面
private static final LinkedList<Runnable> sFinishers = new LinkedList<>();

// Make sure any pending writes are now committed.
//看这个注释写的，确认没有正在写入的操作，就是这个waitToFinish方法，
//这个if判断，可以看实现，只要taget小于11判断就是true，我们现在都是大于11了，所以，这里是false
//然后，前面取了一个非，所以，我们现在这里能进去
//如果要是小于11呢？看activity的onPause方法里面，你会有新发现
if (!r.isPreHoneycomb()) {
    QueuedWork.waitToFinish();
}

public static void waitToFinish() {
    ...
    try {
        //while循环
        while (true) {
            Runnable finisher;
            synchronized (sLock) {
              //从sFinishers队列中取出runnable
                finisher = sFinishers.poll();
            }
            if (finisher == null) {
                //空(队列中没有数据了)就中止while循环
                break;
            }
            //执行runnable
            finisher.run();
        }
    } finally {
        sCanDelay = true;
    }
    ...
}

static File makeBackupFile(File prefsFile) {
    return new File(prefsFile.getPath() + ".bak");
}

SharedPreferencesImpl(File file, int mode) {
    mFile = file;
    //就是这个变量
    mBackupFile = makeBackupFile(file);
    ...
}

private void writeToFile(MemoryCommitResult mcr, boolean isFromSyncCommit) {
    ...
    // Attempt to write the file, delete the backup and return true as atomically as
    // possible.  If any exception occurs, delete the new file; next time we will restore
    // from the backup.
    try {
        FileOutputStream str = createFileOutputStream(mFile);
        if (DEBUG) {
            outputStreamCreateTime = System.currentTimeMillis();
        }
        if (str == null) {
            mcr.setDiskWriteResult(false, false);
            return;
        }
        XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);
        writeTime = System.currentTimeMillis();
        FileUtils.sync(str);
        fsyncTime = System.currentTimeMillis();
        str.close();
        ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0);
        if (DEBUG) {
            setPermTime = System.currentTimeMillis();
        }
        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();
        }
        // Writing was successful, delete the backup file if there is one.
        //就是这里，写入操作在前面，如果前面没有异常，那就正常写完了，自然就会走到这里
        //如果前面异常，自然就不会走到这里
        mBackupFile.delete();
    ...
}