Android-SharedPreferences源码学习与最佳实践

最近有个任务是要做应用启动时间优化，然后记录系统启动的各个步骤所占用的时间，发现有一个方法是操作SharedPreferences的，里面仅仅是读了2个key，然后更新一下值，然后再写回去，耗时竟然在500ms以上（应用初次安装的时候），感到非常吃惊。以前只是隐约的知道SharedPreferences是跟硬盘上的一个xml文件对应的，具体的实现还真没研究过，下面我们就来看看SharedPreferences到底是个什么玩意，为什么效率会这么低？

SharedPreferences是存放在ContextImpl里面的，所以先看写ContextImpl这个类：

ContextImpl.java（https://github.com/android/platform_frameworks_base/blob/master/core/java/android/app/ContextImpl.java）：

/**
   * Map from package name, to preference name, to cached preferences.
   */
private static ArrayMap<string, arraymap<string,="" sharedpreferencesimpl="">> sSharedPrefs;//在内存的一份缓存
 
@Override
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;
    }</string,></string,></string,></string,>

getSharedPreferences()做的事情很简单，一目了然，我们重点看下SharedPreferencesImpl.java这个类：
SharedPreferencesImpl.java（https://github.com/android/platform_frameworks_base/blob/master/core/java/android/app/SharedPreferencesImpl.java）
首先是构造函数：

SharedPreferencesImpl(File file, int mode) {
        mFile = file;//这个是硬盘上的文件
        mBackupFile = makeBackupFile(file);//这个是备份文件，当mFile出现crash的时候，会使用mBackupFile来替换
        mMode = mode;//这个是打开方式
        mLoaded = false;//这个是一个标志位，文件是否加载完成，因为文件的加载是一个异步的过程
        mMap = null;//保存数据用
        startLoadFromDisk();//开始从硬盘异步加载
}
//还两个很重要的成员：
private int mDiskWritesInFlight = 0;  //有多少批次没有commit到disk的写操作，每个批次可能会对应多个k-v
private final Object mWritingToDiskLock = new Object();//写硬盘文件时候加锁

//从硬盘加载
private void startLoadFromDisk() {
        synchronized (this) {//先把状态置为未加载
            mLoaded = false;
        }
        new Thread("SharedPreferencesImpl-load") {//开了一个线程，异步加载
            public void run() {
                synchronized (SharedPreferencesImpl.this) {
                    loadFromDiskLocked();//由SharedPreferencesImpl.this锁保护
                }
            }
        }.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 = Libcore.os.stat(mFile.getPath());
            if (mFile.canRead()) {
                BufferedInputStream str = null;
                try {
                    str = new BufferedInputStream(new FileInputStream(mFile), 16*1024);//从硬盘把数据读出来
                    map = XmlUtils.readMapXml(str);//做xml解析
                } 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;  //保存到mMap
            mStatTimestamp = stat.st_mtime;//记录文件的时间戳
            mStatSize = stat.st_size;//记录文件的大小
        } else {
            mMap = new HashMap<string, object="">();
        }
        notifyAll();//唤醒等待线程
    }
</string,>

然后我们随便看一个读请求：

public int getInt(String key, int defValue) {
       synchronized (this) {//还是得首先获取this锁
           awaitLoadedLocked(); //这一步完成以后，说明肯定已经加载完了
           Integer v = (Integer)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) {
            }
        }
    }

看一下写操作，写是通过Editor来做的：

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.
    //注释很有意思，获取edit的时候，可以把这个同步去掉，但是如果去掉就需要在Editor上做一些工作（？？？）。
    //但是，好处是context.getSharedPreferences(..).edit().putString(..).apply()整个过程都不阻塞
        synchronized (this) {//还是先等待加载完成
            awaitLoadedLocked();
        }
        return new EditorImpl();//返回一个EditorImpl，它是一个内部类
    }

public final class EditorImpl implements Editor {
    //写操作暂时会把数据放在这里面
        private final Map<string, object=""> mModified = Maps.newHashMap();//由this锁保护
    //是否要清空所有的preferences
    private boolean mClear = false;
 
    public Editor putInt(String key, int value) {
            synchronized (this) {//首先获取this锁
                mModified.put(key, value);//并不是直接修改mMap，而是放到mModified里面
                return this;
            }
        }
}
</string,>

看一下commit：

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()这个方法主要是用来更新内存缓存的mMap：

// Returns true if any changes were made
private MemoryCommitResult commitToMemory() {
    MemoryCommitResult mcr = new MemoryCommitResult();
    synchronized (SharedPreferencesImpl.this) { //加SharedPreferencesImpl锁，写内存的时候不允许读
        // We optimistically don't make a deep copy until a memory commit comes in when we're already writing to disk.
        if (mDiskWritesInFlight > 0) {//如果存在没有提交的写， mDiskWritesInFlight是SharedPreferences的成员变量 
            // 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);//clone一个mMap，没明白！
        }
        mcr.mapToWriteToDisk = mMap;
        mDiskWritesInFlight++;//批次数目加1
 
        boolean hasListeners = mListeners.size() > 0;
        if (hasListeners) {
            mcr.keysModified = new ArrayList<string>();
            mcr.listeners = new HashSet<onsharedpreferencechangelistener>(mListeners.keySet());
        }
        synchronized (this) {//对当前的Editor加锁
            if (mClear) {//只有当调用了clear()才会把这个值置为true
                if (!mMap.isEmpty()) {//如果mMap不是空
                    mcr.changesMade = true;
                    mMap.clear();//清空mMap。mMap里面存的是整个的Preferences
                }
                mClear = false;
            }
 
            for (Map.Entry<string, object=""> e : mModified.entrySet()) {//遍历所有要commit的entry
                String k = e.getKey();
                Object v = e.getValue();
                if (v == this) {  // magic value for a removal mutation
                    if (!mMap.containsKey(k)) {
                        continue;
                    }
                    mMap.remove(k);
                } else {
                    boolean isSame = false;
                    if (mMap.containsKey(k)) {
                        Object existingValue = mMap.get(k);
                        if (existingValue != null && existingValue.equals(v)) {
                            continue;
                        }
                    }
                    mMap.put(k, v);//这里是往里面放，因为最外层有对SharedPreferencesImpl.this加锁，写是没问题的
                }
 
                mcr.changesMade = true;
                if (hasListeners) {
                    mcr.keysModified.add(k);
                }
            }
 
            mModified.clear();//清空editor
        }
    }
    return mcr;
}</string,></onsharedpreferencechangelistener></string></string,>

//这是随后的写硬盘
 private void enqueueDiskWrite(final MemoryCommitResult mcr, final Runnable postWriteRunnable) {
        final Runnable writeToDiskRunnable = new Runnable() {
                public void run() {
                    synchronized (mWritingToDiskLock) {
                        writeToFile(mcr);
                    }
                    synchronized (SharedPreferencesImpl.this) {
                        mDiskWritesInFlight--;
                    }
                    if (postWriteRunnable != null) {
                        postWriteRunnable.run();
                    }
                }
            };
 
        final boolean isFromSyncCommit = (postWriteRunnable == null);//如果是commit，postWriteRunnable是null
 
        // Typical #commit() path with fewer allocations, doing a write on
        // the current thread.
        if (isFromSyncCommit) {//如果是调用的commit
            boolean wasEmpty = false;
            synchronized (SharedPreferencesImpl.this) {
                wasEmpty = mDiskWritesInFlight == 1;//如果只有一个批次等待写入
            }
            if (wasEmpty) {
                writeToDiskRunnable.run();//不用另起线程，直接在当前线程执行，很nice的优化！
                return;
            }
        }
    //如果不是调用的commit，会走下面的分支
    //如或有多个批次等待写入，另起线程来写，从方法名可以看出来也是串行的写，写文件本来就应该串行！
        QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
    }

看下writeToDiskRunnable都干了些什么：

final Runnable writeToDiskRunnable = new Runnable() {//这是工作在另一个线程
        public void run() {
            synchronized (mWritingToDiskLock) {//mWritingToDiskLock是SharedPreferencesImpl的成员变量，保证单线程写文件，
                           //不能用this锁是因为editor上可能会存在多个commit或者apply
                           //也不能用SharedPreferences锁，因为会阻塞读，不错！
                writeToFile(mcr);//写到文件
            }
            synchronized (SharedPreferencesImpl.this) {
                mDiskWritesInFlight--;//批次减1
            }
            if (postWriteRunnable != null) {
                postWriteRunnable.run();//这个是写完以后的回调
            }
        }
    };

下面是真正要写硬盘了：

// Note: must hold mWritingToDiskLock
    private void writeToFile(MemoryCommitResult mcr) {
        // Rename the current file so it may be used as a backup during the next read
        if (mFile.exists()) {
            if (!mcr.changesMade) {//如果没有修改，直接返回
                // If the file already exists, but no changes were
                // made to the underlying map, it's wasteful to
                // re-write the file.  Return as if we wrote it
                // out.
                mcr.setDiskWriteResult(true);
                return;
            }
            if (!mBackupFile.exists()) {//先备份
                if (!mFile.renameTo(mBackupFile)) {
                    Log.e(TAG, "Couldn't rename file " + mFile
                          + " to backup file " + mBackupFile);
                    mcr.setDiskWriteResult(false);
                    return;
                }
            } else {//删除重建
                mFile.delete();
            }
        }
 
        // 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 (str == null) {
                mcr.setDiskWriteResult(false);
                return;
            }
            XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);
            FileUtils.sync(str);//强制写到硬盘
            str.close();
            ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0);
            try {
                final StructStat stat = Libcore.os.stat(mFile.getPath());
                synchronized (this) {
                    mStatTimestamp = stat.st_mtime;//更新文件时间戳
                    mStatSize = stat.st_size;//更新文件大小
                }
            } catch (ErrnoException e) {
                // Do nothing
            }
            // Writing was successful, delete the backup file if there is one.
            mBackupFile.delete();
            mcr.setDiskWriteResult(true);
            return;
        } catch (XmlPullParserException e) {
            Log.w(TAG, "writeToFile: Got exception:", e);
        } catch (IOException e) {
            Log.w(TAG, "writeToFile: Got exception:", e);
        }
        // Clean up an unsuccessfully written file
        if (mFile.exists()) {
            if (!mFile.delete()) {
                Log.e(TAG, "Couldn't clean up partially-written file " + mFile);
            }
        }
        mcr.setDiskWriteResult(false);
    }

public static boolean sync(FileOutputStream stream) {
        try {
            if (stream != null) {
                stream.getFD().sync();//强制写硬盘
            }
            return true;
        } catch (IOException e) {
        }
        return false;
}

这里面还有一个跟commit长得很像的方法叫apply():

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);//这个地方传递的postWriteRunnable不再是null
 
    // 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);
}

我们已经看过enqueueDiskWrite()这个方法了，因为参数postWriteRunnable不是null，最终会执行：
QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
这是在单独的线程上做写硬盘的操作，写完以后会回调postWriteRunnable，等待写硬盘完成！

从上面的代码可以得出以下结论：
（1）SharedPreferences在第一次加载的时候，会从硬盘异步的读文件，然后会在内存做缓存。
（2）SharedPreferences的读都是读的内存缓存。
（3）如果是commmit()写，是先把数据更新到内存，然后同步到硬盘，整个过程是在同一个线程中同步来做的。
（4）如果是apply()写,首先也是写到内存，但是会另起一个线程异步的来写硬盘。因为我们在读的时候，是直接从内存读取的，因此，用apply()而不是commit()会提高性能。
（5）如果有多个key要写入，不要每次都commit或者apply，因为这里面会存在很多的加锁操作，更高效的使用方式是这样：editor.putInt("","").putString("","").putBoolean("","").apply();并且所有的putXXX()的结尾都会返回this，方便链式编程。
（6）这里面有三级的锁：SharedPreferences，Editor， mWritingToDiskLock。
mWritingToDiskLock是对应硬盘上的文件，Editor是保护mModified的，SharedPreferences是保护mMap的。
参考：
http://stackoverflow.com/questions/19148282/read-speed-of-sharedpreferences
http://stackoverflow.com/questions/12567077/is-sharedpreferences-access-time-consuming

原文：http://www.2cto.com/kf/201312/268547.html

posted on 2015-02-03 11:05 veins 阅读(604) 评论(0) 编辑收藏举报

刷新页面返回顶部

veins

Android-SharedPreferences源码学习与最佳实践

导航