Android中SharedPreferences源码解析与性能优化

SP XML文件与SharedPreferences对象关系解读

data/data/packagename/shared_prefs 中的xml文件，以下简称sp文件

ContextIml对象中通过Map集合缓存了多个SharedPreference对象,该Map集合是全局的,key对应shared_prefs文件名,value对应SharedPreferenceImpl(SharedPreferences接口的实现类)对象。因此,shared_prefs文件与内存中的SharedPreferencesImpl对象是一一对应的关系。

shared_prefs xml文件中的键值对数据则存储在SharedPreferencesImpl对象内部的Map集合中.因此shared_prefs xml文件中的键值对数据和SharedPreferencesImpl中的Map对象是一一对应的关系。

Context.getSharedPreferences(String name,int mode)方法解读
优先从全局缓存Map中读取,有则返回，没有则新建一个SharedPreferencesImpl对象存储到缓存Map中，由此可见一个shared_prefs文件在内存中只对应一个SharedPreferencesImpl对象，源码如下：

//step 1 获取SharedPreferences对象
public SharedPreferences getSharedPreferences(String name, int mode) {
        SharedPreferencesImpl sp;
        synchronized (ContextImpl.class) {
            if (sSharedPrefs == null) {
                sSharedPrefs = new ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>>();
            }

            final String packageName = getPackageName();
            ArrayMap<String, SharedPreferencesImpl> packagePrefs = sSharedPrefs.get(packageName);
            if (packagePrefs == null) {
                packagePrefs = new ArrayMap<String, SharedPreferencesImpl>();
                sSharedPrefs.put(packageName, packagePrefs);
            }

            // At least one application in the world actually passes in a null
            // name.  This happened to work because when we generated the file name
            // we would stringify it to "null.xml".  Nice.
            if (mPackageInfo.getApplicationInfo().targetSdkVersion <
                    Build.VERSION_CODES.KITKAT) {
                if (name == null) {
                    name = "null";
                }
            }

            sp = packagePrefs.get(name);
            if (sp == null) {
                File prefsFile = getSharedPrefsFile(name);
                sp = new SharedPreferencesImpl(prefsFile, mode);
                packagePrefs.put(name, 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对象时会首先创建一个shared_prefs文件，然后读取文件的数据存储到SharedPreferences对象的Map中，注意此操作是在子线程中进行的，此操作完成后会将mLoaded标记置为true，代表shared_prefs文件已经加载完成.

//step 2 Map中没有则新建一个SharedPreferencesImpl对象
SharedPreferencesImpl(File file, int mode) {
        mFile = file;
        mBackupFile = makeBackupFile(file);
        mMode = mode;
        mLoaded = false;
        mMap = null;
        startLoadFromDisk();
    }

//step 3 第一次创建SharedPreferencesImpl后，在子线程中执行读取xml文件
private void startLoadFromDisk() {
        synchronized (this) {
            mLoaded = false;
        }
        new Thread("SharedPreferencesImpl-load") {
            public void run() {
                synchronized (SharedPreferencesImpl.this) {
                    loadFromDiskLocked();
                }
            }
        }.start();
    }

//step 4 将xml文件中的数据读取到SharedPreferencesImpl对象内部的Map中，并将mLoaded赋值为true，然后唤醒其他线程继续执行
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();
    }

对shared_prefs文件的读写操作都会判断mLoaded状态，如果mLoaded为false，则当前调用线程会等待。

//写操作会等待mLoaded=true
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();
    }

//读操作也会等待mLoaded=true
public String getString(String key, String defValue) {
        synchronized (this) {
            awaitLoadedLocked();
            String v = (String)mMap.get(key);
            return v != null ? v : defValue;
        }
    }

每次edit都会新建一个Editor对象，每次写操作之后，数据都是保存中Editor对象内部的临时容器Map中，且clear操作也只是改变其内部的clear字段值为true，

public final class EditorImpl implements Editor {
        private final Map<String, Object> mModified = Maps.newHashMap();
        private boolean mClear = false;

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

当进行了commit或者apply操作之后，会将临时容器Map和SharedPreferencesImpl内部的Map进行数据对比，然后将最终的Map数据写入到shared_prefs文件中.

commit和apply的区别

commit会直接在当前线程提交
apply则会放入一个线程池中执行。注意ActivityThread handleStopActivity方法中会检查这个线程池中的任务，如果任务未完成则会等待。

private void handleStopActivity(IBinder token, boolean show, int configChanges, int seq) {

    // 省略无关。。
    // Make sure any pending writes are now committed.
    if (!r.isPreHoneycomb()) {
        QueuedWork.waitToFinish();
    }

    // 省略无关。。
}

public static void waitToFinish() {
    Runnable toFinish;
    while ((toFinish = sPendingWorkFinishers.poll()) != null) {
        toFinish.run();
    }
}

此外SharedPreferences并不支持多进程，对于mode是多进程模式也仅仅是重新加载文件到内存中。
另外SharedPreferences 内部是通过加锁保证线程安全的。

优化建议：

• 不要存放大的key和value在SharedPreferences中，否则会一直存储在内存中得不到释放，内存使用过高会频发引发GC，导致界面丢帧甚至ANR。
• 不相关的配置选项最好不要放在一起，单个文件越大读取速度则越慢。
• 读取频繁的key和不频繁的key尽量不要放在一起（如果整个文件本身就较小则忽略，为了这点性能添加维护得不偿失）。
• 不要每次都edit，因为每次都会创建一个新的EditorImpl对象，最好是批量处理统一提交。否则edit().commit每次创建一个EditorImpl对象并且进行一次IO操作，严重影响性能。
• commit发生在UI线程中，apply发生在工作线程中，对于数据的提交最好是批量操作统一提交。虽然apply发生在工作线程（不会因为IO阻塞UI线程）但是如果添加任务较多也有可能带来其他严重后果（参照ActivityThread源码中handleStopActivity方法实现）
• 尽量不要存放json和html，这种可以直接文件缓存。
• 不要指望它能够跨进程通信 Context.PROCESS
• 最好提前初始化SharedPreferences，避免SharedPreferences第一次创建时读取文件线程未结束而出现等待情况。