SharedPreferences详解

1. SharedPreferences

   SharedPreferences在文件中以键值对形式保存数据，适合保存少量数据。使用SharedPreferences可以通过下面两种方式：

   • 通过Context的getSharedPreferences()

   • 通过Activity的getSharedPreferences()

通过Context的方式是当前App都可以访问或者有相同user ID的其他App也可以访问，通过Activity是只能当前这个activity对象访问，并且这个SharedPreferences的文件名是activity的类名。
有几种操作模式：

Context.MODE_PRIVATE
Context.MODE_WORLD_READABLE
Context.MODE_WORLD_WRITEABLE
Context.MODE_MULTI_PROCESS
第一种是默认的，后面三个被废弃了，分别表示可以被其他的App读取和写入以及多进程中访问Preferences时设置会在修改时检查避免同时修改文件，有的提到了MODE_APPEND，这个是用在openFileOutput中的，文件存在会在文件后面追加而不是覆盖，Preferences没有这个标志，但实际上Preferences也是对文件的操作，只不过的相关操作中没有用到。

其中MODE_PRIVATE表示是只能被当前App访问或者被有相同user ID的App们访问，相同的user ID表示在manifest中设置android:sharedUserId=”com.my.app”，并且使用相同的签名打包，获取方法方法：
Context ctx = createPackageContext(“com.my.app.first”, CONTEXT_RESTRICTED);
prefs = context.getSharedPreferences(“PreferencesName”, Context.MODE_PRIVATE);
虽然可以用但是可能还是会有问题，B如果打算获取A的Preferences，有可能只能获取到B自己的，获取不到A的，必须在调用B自己的getSharedPreferences()之前先调用获取A的getSharedPreferences()，(具体参见How to read other app’s SharedPreferences (same user ID)?)，

下面看一下具体的实现：
Context的实现类是ContextImpl，SharedPreferences的实现类是SharedPreferencesImpl，
ContextImpl中的getSharedPreferences():

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

sSharedPrefs 是一个静态变量，是一个Map，保存包名和包名对应的SharedPreferences对象，不存在就创建，保证只有一个实例，其中SharedPreferences的名字可以为null，也就是getSharedPreferences(String name, int mode)中可以name==null。
SharedPreferencesImpl中

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

mFile 是保存Preferences中数据的file，mBackupFile 是mFile的备份，mMode 就是getSharedPreferences中的mode，mMap 是Preferences中的键值对，startLoadFromDisk是读取数据，

    private void startLoadFromDisk() {        synchronized (this) {            mLoaded = false;        }        new Thread("SharedPreferencesImpl-load") {            public void run() {                synchronized (SharedPreferencesImpl.this) {                    loadFromDiskLocked();                }            }        }.start();    }

使用了线程锁，保证同时只有一个线程访问，然后子线程调用loadFromDiskLocked()，

    //部分删减    private void loadFromDiskLocked() {        //......        if (mBackupFile.exists()) {            mFile.delete();            mBackupFile.renameTo(mFile);        }        //......        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);                }                 //.....            }        }        mLoaded = true;        if (map != null) {            mMap = map;            mStatTimestamp = stat.st_mtime;            mStatSize = stat.st_size;        }         //......    }

其中数据从mBackupFile读取出来，赋值给mMap，是一次全部读取，所以Preferences不适合保存大量数据，否则效率很慢，而使用mBackupFile是为了在提交操作写mFile文件时读取的数据没问题，虽然数据可能是旧的，这也符合逻辑，如果采用异步提交，立即读取数据就有可能还是旧的。
继续往下看，看读取和写入操作：
读取

    public int getInt(String key, int defValue) {        synchronized (this) {            awaitLoadedLocked();            Integer v = (Integer)mMap.get(key);            return v != null ? v : defValue;        }    }

以getInt为例，同样加了线程锁，保证同时只有一个线程访问Preferences，直接从mMap读取，为什么不是重新读文件然后获取就必须要讲讲提交数据了，这里猜测可能是在put数据或commit时赋值给了mMap，下面看看是不是。
提交操作都是封装在Editor类中，实现类是EditorImpl，以putInt为例：

        public Editor putInt(String key, int value) {            synchronized (this) {                mModified.put(key, value);                return this;            }        }

同样是加了同步锁，注意这里是保存到了mModified中，这样给mMap赋值可能就是在commit中，提交操作设计的方法有几个分别是apply，commit，commitToMemory，apply和commit都调用了commitToMemory，

        //部分删减        private MemoryCommitResult commitToMemory() {            synchronized (SharedPreferencesImpl.this) {                mcr.mapToWriteToDisk = mMap;//提交写文件时将mcr.mapToWriteToDisk中保存的数据写入文件                mDiskWritesInFlight++;                synchronized (this) {                    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);                        }                    }                    mModified.clear();                }            }            return mcr;        }

这里面进行了赋值，在分别看看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;        }

可以看出基本上就是SharedPreferencesImpl.this.enqueueDiskWrite的参数不一样，一个传了postWriteRunnable，一个是null，看一下enqueueDiskWrite：

    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);        // Typical #commit() path with fewer allocations, doing a write on        // the current thread.        if (isFromSyncCommit) {            boolean wasEmpty = false;            synchronized (SharedPreferencesImpl.this) {                wasEmpty = mDiskWritesInFlight == 1;            }            if (wasEmpty) {                writeToDiskRunnable.run();                return;            }        }        QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);    }

其中isFromSyncCommit这个变量控制，当postWriteRunnable参数不为空时为false，会执行QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);在子线程中执行写文件操作，否则就在当前线程（主线程）执行写操作，这样commit就是同步提交，apply是异步提交。还有writeToFile写文件：

    //部分删减    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 (!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);//创建一个新文件            XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);//将mcr.mapToWriteToDisk中的数据写入            FileUtils.sync(str);            str.close();            //这里用到了getSharedPreferences的mode            ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0);            // Writing was successful, delete the backup file if there is one.            mBackupFile.delete();//已经提交成功，需要删除备份文件，否则再读取数据可能就是从mBackupFile中读取            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);    }