SharePreferences源码分析

最近在项目中使用了SharePreferences，因此看了一下SharePreferences相关的源码，在此进行一下记录
SharePreferences在Android提供的几种数据存储方式中属于轻量级的键值存储方式，以XML文件方式保存数据，通常用来存储一些用户行为开关状态等，一般的存储一些常见的数据类型。

SharePreferences保存的xml文件存放于 /data/data/应用程序包/shared_prefs 的目录下
SharePreferences是接口，位于android.content包中
SharePreferencesImpl是对于SharePreferences的实现，位于android.app包下
以下是一段SharePreferences的写入以及读取的例子：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    SharedPreferences sp = getSharedPreferences("data", MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putString("name", "username");
    editor.commit();

    String s = sp.getString("name", "");
}

第6行调用了ContextWrapper中的getSharedPreferences方法：

@Override
public SharedPreferences getSharedPreferences(String name, int mode) {
    return mBase.getSharedPreferences(name, mode);
}

这里调用了mBase的getSharedPreferences，mBase是ContextWrapper持有的Context变量，很明显实际类型即是ContextImpl（Context的实现类）：

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

上面代码首先检查了是否缓存过对应的SharedPreferences，如果没有缓存则创建SharedPreferencesImpl对象（第9行）：

SharedPreferencesImpl(File file, int mode) {
    mFile = file;
    mBackupFile = makeBackupFile(file);
    mMode = mode;
    mLoaded = false;
    mMap = null;
    startLoadFromDisk();
}

简单说一下这里的几个变量：

• mFile：当前的xml文件，即/data/data/应用程序包/shared_prefs/xxx.xml
• mBackupFile：当前xml备份文件，名为xxx.xml.bak
• mMode：int类型，表示打开的模式
• mLoaded：boolean类型，表示是否已经加载xml文件
• mMap：xml的数据再内存中的储存形式

在SharedPreferencesImpl构造函数中，调用了startLoadFromDisk方法加载xml中的数据：

private void startLoadFromDisk() {
    synchronized (this) {
        mLoaded = false;
    }
    new Thread("SharedPreferencesImpl-load") {
        public void run() {
            synchronized (SharedPreferencesImpl.this) {
                loadFromDiskLocked();
            }
        }
    }.start();
}
	
private void loadFromDiskLocked() {
    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 map = null;
    StructStat stat = null;
    try {
        stat = Os.stat(mFile.getPath());
        if (mFile.canRead()) {
            BufferedInputStream str = null;
            try {
                str = new BufferedInputStream(
                        new FileInputStream(mFile), 16*1024);
                map = XmlUtils.readMapXml(str);
            } catch (XmlPullParserException e) {
                Log.w(TAG, "getSharedPreferences", e);
            } catch (FileNotFoundException e) {
                Log.w(TAG, "getSharedPreferences", e);
            } catch (IOException e) {
                Log.w(TAG, "getSharedPreferences", e);
            } finally {
                IoUtils.closeQuietly(str);
            }
        }
    } catch (ErrnoException e) {
    }
    mLoaded = true;
    if (map != null) {
        mMap = map;
        mStatTimestamp = stat.st_mtime;
        mStatSize = stat.st_size;
    } else {
        mMap = new HashMap<String, Object>();
    }
    notifyAll();
}

在startLoadFromDisk方法中，SharedPreferencesImpl开启了新的子线程，并持有对象锁来调用loadFromDiskLocked方法，通过XmlUtils工具类把xml读取为内存中的Map形式，最后通过notifyAll通知所有wait的地方

看完SharedPreferencesImpl的初始化，我们来看一下它的get方法，以例子中的getString为例：

public String getString(String key, String defValue) {
    synchronized (this) {
        awaitLoadedLocked();
        String v = (String)mMap.get(key);
        return v != null ? v : defValue;
    }
}
	
private void awaitLoadedLocked() {
    if (!mLoaded) {
        // Raise an explicit StrictMode onReadFromDisk for this
        // thread, since the real read will be in a different
        // thread and otherwise ignored by StrictMode.
        BlockGuard.getThreadPolicy().onReadFromDisk();
    }
    while (!mLoaded) {
        try {
            wait();
        } catch (InterruptedException unused) {
        }
    }
}

该方法在持有对象锁的情况下，通过awaitLoadedLocked方法检查是否已经从xml加载到内存map中，然后直接读取map中的数据即可

awaitLoadedLocked方法处理了一些与StrictMode相关的问题，在此不做讨论，在它发现SharedPreferencesImpl还没有加载完毕时，会调用wait方法把当前线程挂起，直到加载完毕通过notifyAll唤醒
看完了SharedPreferencesImpl的get方法，我们再来看一下如何向其中插入新的数据：

public Editor edit() {
    // TODO: remove the need to call awaitLoadedLocked() when
    // requesting an editor.  will require some work on the
    // Editor, but then we should be able to do:
    //
    //      context.getSharedPreferences(..).edit().putString(..).apply()
    //
    // ... all without blocking.
    synchronized (this) {
        awaitLoadedLocked();
    }

    return new EditorImpl();
}

当我们调用edit方法时，会返回一个新的Edit接口的实现类EditorImpl，EditorImpl使用的是默认构造函数，它包含了两个成员变量：

• mModified：Map类型，用于存储修改的键值对
• mClear：boolean类型，用于标识是否清空SharedPreferences

获取EditorImpl实例后，我们会调用其put或者clear方法修改SharedPreferences：

public Editor putString(String key, String value) {
    synchronized (this) {
        mModified.put(key, value);
        return this;
    }
}
		
public Editor clear() {
    synchronized (this) {
        mClear = true;
        return this;
    }
}

put方法会把我们的修改存入mModified变量，而clear方法会把mClear变量置为true
当我们修改SharedPreferences完成后，会调用Editor的apply或者commit方法（apply为异步提交，commit为同步提交）：

public void apply() {
    final MemoryCommitResult mcr = commitToMemory();
    final Runnable awaitCommit = new Runnable() {
            public void run() {
                try {
                    mcr.writtenToDiskLatch.await();
                } catch (InterruptedException ignored) {
                }
            }
        };

    QueuedWork.add(awaitCommit);

    Runnable postWriteRunnable = new Runnable() {
            public void run() {
                awaitCommit.run();
                QueuedWork.remove(awaitCommit);
            }
        };

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

两个方法都首先调用了commitToMemory方法，把修改同步到内存中，然后都把写入文件中的任务加入到了队列当中等待执行
写入文件的任务使用的同步工具是CounDownLatch，commit在当前线程调用了await方法等待写入完成并返回Boolean表示写入状态，而apply在把写入任务加入队列后则返回了
在看commitToMemory方法之前，我们先来看看他的返回结果：MemoryCommitResult类

// Return value from EditorImpl#commitToMemory()
private static class MemoryCommitResult {
    public boolean changesMade;  // any keys different?
    public List<String> keysModified;  // may be null
    public Set<OnSharedPreferenceChangeListener> listeners;  // may be null
    public Map<?, ?> mapToWriteToDisk;
    public final CountDownLatch writtenToDiskLatch = new CountDownLatch(1);
    public volatile boolean writeToDiskResult = false;

    public void setDiskWriteResult(boolean result) {
        writeToDiskResult = result;
        writtenToDiskLatch.countDown();
    }
}

MemoryCommitResult中：writeToDiskResult用于表示写入文件的结果，mapToWriteToDisk表示写入文件的map，即Editor更新后的map
commitToMemory方法如下：

// Returns true if any changes were made
private MemoryCommitResult commitToMemory() {
    MemoryCommitResult mcr = new MemoryCommitResult();
    synchronized (SharedPreferencesImpl.this) {
        // We optimistically don't make a deep copy until
        // a memory commit comes in when we're already
        // writing to disk.
        if (mDiskWritesInFlight > 0) {
            // We can't modify our mMap as a currently
            // in-flight write owns it.  Clone it before
            // modifying it.
            // noinspection unchecked
            mMap = new HashMap<String, Object>(mMap);
        }
        mcr.mapToWriteToDisk = mMap;
        mDiskWritesInFlight++;

        boolean hasListeners = mListeners.size() > 0;
        if (hasListeners) {
            mcr.keysModified = new ArrayList<String>();
            mcr.listeners =
                    new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
        }

        synchronized (this) {
            if (mClear) {
                if (!mMap.isEmpty()) {
                    mcr.changesMade = true;
                    mMap.clear();
                }
                mClear = false;
            }

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

                mcr.changesMade = true;
                if (hasListeners) {
                    mcr.keysModified.add(k);
                }
            }

            mModified.clear();
        }
    }
    return mcr;
}

在第26行我们可以看到，Editor首先通过mClear变量决定是否清空mMap，然后通过mModified变量决定如何修改mMap