android app深度优化—Shared Preference源码详解

前言

SharedPreferences是Android提供的数据持久化的一种手段，适合单进程、小批量的数据存储与访问。因为SharedPreferences的实现是基于单个xml文件实现的，并且，所有持久化数据都是一次性加载到内存，如果数据过大，是不合适采用SharedPreferences存放的。而适用的场景是单进程的原因同样如此，由于Android原生的文件访问并不支持多进程互斥，所以SharePreferences也不支持，如果多个进程更新同一个xml文件，就可能存在同不互斥问题。

SharedPreferences简单使用

创建

第一个参数是储存的xml文件名称，第二个是打开方式，一般就用Context.MODE_PRIVATE；

SharedPreferences sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE);
复制代码

写入

//可以创建一个新的SharedPreference来对储存的文件进行操作
​
SharedPreferences sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE);
​
//像SharedPreference中写入数据需要使用Editor
​
SharedPreference.Editor editor = sp.edit();
​
//类似键值对
​
editor.putString("name", "string");
​
editor.putInt("age", 0);
​
editor.putBoolean("read", true);
​
//editor.apply();
​
editor.commit();
复制代码

• apply和commit都是提交保存，区别在于apply是异步执行的，不需要等待。不论删除，修改，增加都必须调用apply或者commit提交保存；
• 关于更新：如果已经插入的key已经存在。那么将更新原来的key；
• 应用程序一旦卸载，SharedPreference也会被删除；

读取

SharedPreference sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE);
​
//第一个参数是键名，第二个是默认值
​
String name=sp.getString("name", "暂无");
​
int age=sp.getInt("age", 0);
​
boolean read=sp.getBoolean("isRead", false);
复制代码

4、检索

SharedPreferences sp=context.getSharedPreferences("名称", Context.MODE_PRIVATE);
​
//检查当前键是否存在
​
boolean isContains=sp.contains("key");
​
//使用getAll可以返回所有可用的键值
​
//Map<String,?> allMaps=sp.getAll();
复制代码

删除

当我们要清除SharedPreferences中的数据的时候一定要先clear()、再commit()，不能直接删除xml文件；

SharedPreference sp=getSharedPreferences("名称", Context.MODE_PRIVATE);
​
SharedPrefence.Editor editor=sp.edit();
​
editor.clear();
​
editor.commit();
复制代码

• getSharedPreference() 不会生成文件，这个大家都知道；
• 删除掉文件后，再次执行commit()，删除的文件会重生，重生文件的数据和删除之前的数据相同；
• 删除掉文件后，程序在没有完全退出停止运行的情况下，Preferences对象所存储的内容是不变的，虽然文件没有了，但数据依然存在；程序完全退出停止之后，数据才会丢失；
• 清除SharedPreferences数据一定要执行editor.clear()，editor.commit()，不能只是简单的删除文件，这也就是最后的结论，需要注意的地方

源码分析

获取SharedPreferences对象的过程

Context是一个抽象类，它的子类中有ContextImpl和ContextWrapper

Context mBase;
public SharedPreferences getSharedPreferences(String name, int mode) {
//这里其实调用的是ContextImpl的getSharedpreferences方法
       return mBase.getSharedPreferences(name, mode);
   }

最终还是要看看ContextImpl中的getSharedPreferences的具体实现：

public SharedPreferences getSharedPreferences(String name, int mode) {
        //当SDK< 19时，如果文件名为null则会初始化名字为"null"
        if (mPackageInfo.getApplicationInfo().targetSdkVersion <
                Build.VERSION_CODES.KITKAT) {
            if (name == null) {
                name = "null";
            }
        }
        File file;
        synchronized (ContextImpl.class) {
        //建立了文件名和File文件的一一对应关系
            if (mSharedPrefsPaths == null) {
                mSharedPrefsPaths = new ArrayMap<>();
            }
            file = mSharedPrefsPaths.get(name);
            if (file == null) {
            //在相应的sharedPreference下新建File，保存文件名为XXX.xml
                file = getSharedPreferencesPath(name);
                mSharedPrefsPaths.put(name, file);
            }
        }
        return getSharedPreferences(file, mode);
    }

新建File的缓存，使用Map建立了文件名和File文件的一一对应，如果没有文件则新建，并放入Map中，如果Map中有需要的文件，则直接使用get方法取出。最终调用了ContextImpl的getSharedPreferences方法。

 public SharedPreferences getSharedPreferences(File file, int mode) {
        SharedPreferencesImpl sp;
        synchronized (ContextImpl.class) {
        //在每个包下面建立了一个File-SharedPreferencesImpl对应关系的ArrayMap
        //getSharedPreferencesCacheLocked()根据包名返回相对应包下的ArrayMap
            final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
            //从file-SharedPreferencesImpl键值对中根据当前file找到SharedPreferencesImpl实例
            sp = cache.get(file);
            //如果没有对应的SharedPreferencesImpl，就新建一个
            if (sp == null) {
            // 检查mode，如果是MODE_WORLD_WRITEABLE或者MODE_MULTI_PROCESS则直接抛异常
                checkMode(mode);
                if (getApplicationInfo().targetSdkVersion >= android.os.Build.VERSION_CODES.O) {
                    if (isCredentialProtectedStorage()
                            && !getSystemService(UserManager.class)
                                    .isUserUnlockingOrUnlocked(UserHandle.myUserId())) {
                        throw new IllegalStateException("SharedPreferences in credential encrypted "
                                + "storage are not available until after user is unlocked");
                    }
                }
                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;
    }

getSharedPreferences（）就是返回了File文件对应的SharedPreferenceImpl对象。

整个获取sharedPreferences的过程：首先建立文件名和File文件的一一对应关系，将数据存储在mSharedPrefsPaths中，如果mSharedPrefsPaths中有文件了，则直接使用不需要重复创建，根据File文件找到对应的SharedPreferenceImpl对象并返回。

SharedPreferencesImpl SharedPreferencesImpl是SharedPreferences的子类，首先看一下SharedPreferences接口中的方法。

public interface SharedPreferences {
    public interface OnSharedPreferenceChangeListener {
        void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key);
    }
    public interface Editor {
        Editor putString(String key, @Nullable String value);
        Editor putStringSet(String key, @Nullable Set<String> values);
        Editor putInt(String key, int value);
        Editor putLong(String key, long value);
        Editor putFloat(String key, float value);
        Editor putBoolean(String key, boolean value);
        Editor remove(String key);
        Editor clear();
        boolean commit();
        void apply();
    }
    Map<String, ?> getAll();
    @Nullable
    String getString(String key, @Nullable String defValue);
    @Nullable
    Set<String> getStringSet(String key, @Nullable Set<String> defValues);
    int getInt(String key, int defValue);
    long getLong(String key, long defValue);
    float getFloat(String key, float defValue);
    boolean getBoolean(String key, boolean defValue);
    boolean contains(String key);
    Editor edit();
    void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener);
    void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener);
}
​

具体方法的实现都在SharedPreferencesImpl中，返回的是SharedPreferencesImpl的对象，首先是构造方法：

SharedPreferencesImpl(File file, int mode) {
        mFile = file;
        //File的备份文件 【fileName.bak】
        mBackupFile = makeBackupFile(file);
        mMode = mode;
        mLoaded = false;
        //真正保存的数据
        mMap = null;
        mThrowable = null;
        //第一次创建时，会去磁盘中加载数据
        startLoadFromDisk();
    }

构造函数中初始化一下数据之后，就会去磁盘中记载数据。

    private void startLoadFromDisk() {
        synchronized (mLock) {
            mLoaded = false;
        }
        //在子线程中加载
        new Thread("SharedPreferencesImpl-load") {
            public void run() {
                loadFromDisk();
            }
        }.start();
    }
    *-----------------------------------------------------*
    private void loadFromDisk() {
        synchronized (mLock) {
        //如果数据已经加载过了，就直接返回。
            if (mLoaded) {
                return;
            }
            //如果备份文件存在，则将原来的文件删除，并将备份文件重命名为mFile
            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<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) {
        } catch (Throwable t) {
            thrown = t;
        }
    
        synchronized (mLock) {
            mLoaded = true;
            mThrowable = thrown;
            try {
                if (thrown == null) {
                    if (map != null) {
                    //mMap是我们真正取数据的map
                        mMap = map;
                        mStatTimestamp = stat.st_mtim;
                        mStatSize = stat.st_size;
                    } else {
                        mMap = new HashMap<>();
                    }
                }
            } catch (Throwable t) {
                mThrowable = t;
            } finally {
                mLock.notifyAll();
            }
        }
    }
​

这里有一个mLock锁，这个锁很重要，这里获取到了锁，当SharedPreferences去操作数据的时候就会先去判断这个锁是否释放了，如果没有，那么就会等待锁释放了在执行，执行到就将数据加载到了内存中，最终保存在mMap中。

SharedPreferencesImpl的构建过程其实就是将数据从磁盘加载进内存，并保存在mMap中。

获取数据

那么接下来看他是怎样获取数据的，这里就看下它的getString（）方法：

public String getString(String key, @Nullable String defValue) {
/*这里一进来就加了一个锁，这个锁是为了防止数据还没加载就执行到这里，那这时就需要将锁释放掉，
但又不对数据进行操作，那这个awaitLoadedLocked（）就起到了这个作用，
这也就是说，数据没加载完是不能对数据进行操作的，这时就阻塞在这里*/
        synchronized (mLock) {
            awaitLoadedLocked();
            String v = (String)mMap.get(key);
            return v != null ? v : defValue;
        }
    }
*------------------------------*
private void awaitLoadedLocked() {
        if (!mLoaded) {
            BlockGuard.getThreadPolicy().onReadFromDisk();
        }
        while (!mLoaded) {
            try {
                mLock.wait(); //将锁释放掉，等待加载完成
            } catch (InterruptedException unused) {
            }
        }
        if (mThrowable != null) {
            throw new IllegalStateException(mThrowable);
        }
    }

读数据的过程就是如果数据已经加载完成就直接在mMap中找到Key中对应的数据，如果没有加载则等待加载完成。

更改数据（Editor）
public Editor edit() {
        synchronized (mLock) {
            awaitLoadedLocked();
        }
        return new EditorImpl();
    }

调用putXXX（）方法，将所有需要修改的数据先保存在一个临时的集合中；

存放完数据，会调用apply（）或者commit()方法，看一下这两个方法的实现。

commitToMemory() 在apply方法中首先会将数据同步到内存，调用的方法就是commitToMemory()，所以先分析这个方法。 这个方法主要做的就是将保存在临时集合中的数据合并到mMap（之前的数据集合）中，同时返回一个MemoryCommitResult对象，将数据保存到磁盘中用到的就是这个类；

private MemoryCommitResult commitToMemory() {
    //当前Memory的状态，其实也就是当需要提交数据到内存的时候，他的值就加一
            long memoryStateGeneration;
            List<String> keysModified = null;
            Set<OnSharedPreferenceChangeListener> listeners = null;
            Map<String, Object> mapToWriteToDisk;
​
            synchronized (SharedPreferencesImpl.this.mLock) {
                if (mDiskWritesInFlight > 0) {
                    mMap = new HashMap<String, Object>(mMap);
                }
                //将需要保存到磁盘中的数据保存到这个集合中
                mapToWriteToDisk = mMap;
                mDiskWritesInFlight++;
    
                boolean hasListeners = mListeners.size() > 0;
                if (hasListeners) {
                    keysModified = new ArrayList<String>();
                    listeners = new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
                }
    
                synchronized (mEditorLock) {
                    boolean changesMade = false;
                    // 如果调用了clear(),那么就会将集合中原先的数据清除掉
                    if (mClear) {
                        if (!mapToWriteToDisk.isEmpty()) {
                            changesMade = true;
                            mapToWriteToDisk.clear();
                        }
                        mClear = false;
                    }
            // 遍历存储在临时集合中的数据，然后合并到原先的数据集合mMap中
                    for (Map.Entry<String, Object> e : mModified.entrySet()) {
                        String k = e.getKey();
                        Object v = e.getValue(); 
                        if (v == this || v == null) {
                            if (!mapToWriteToDisk.containsKey(k)) {
                                continue;
                            }
                            mapToWriteToDisk.remove(k);
                        } else {
                            if (mapToWriteToDisk.containsKey(k)) {
                                Object existingValue = mapToWriteToDisk.get(k);
                                if (existingValue != null && existingValue.equals(v)) {
                                    continue;
                                }
                            }
                            mapToWriteToDisk.put(k, v);
                        }
    
                        changesMade = true;
                        if (hasListeners) {
                            keysModified.add(k);
                        }
                    }
                    mModified.clear();
                    if (changesMade) {
                        mCurrentMemoryStateGeneration++;
                    }
                    memoryStateGeneration = mCurrentMemoryStateGeneration;
                }
            }
            return new MemoryCommitResult(memoryStateGeneration, keysModified, listeners,
                    mapToWriteToDisk);
        }

接下来看一下apply方法

CountDownLatch
1、CountDownLatch end = new CountDownLatch(N); //构造对象时候 需要传入参数N
​
2、end.await() 能够阻塞线程 直到调用N次end.countDown() 方法才释放线程
​
3、end.countDown() 可以在多个线程中调用 计算调用次数是所有线程调用次数的总和
​
apply（）
//构造函数中传入1，也就说明调用一次countDown()会唤醒线程
 final CountDownLatch writtenToDiskLatch = new CountDownLatch(1);
 public void apply() {
            final long startTime = System.currentTimeMillis();
            //先将数据同步到内存，返回的是MermoryCommitResult对象
            final MemoryCommitResult mcr = commitToMemory();
            final Runnable awaitCommit = new Runnable() {
                    @Override
                    public void run() {
                        try {
  // writtenToDiskLatch是一个CountDownLatch对象，除非数据全部同步到磁盘，否则这里就一直阻塞
                            mcr.writtenToDiskLatch.await();
                        } catch (InterruptedException ignored) {
                        }
​
                        if (DEBUG && mcr.wasWritten) {
                            Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration
                                    + " applied after " + (System.currentTimeMillis() - startTime)
                                    + " ms");
                        }
                    }
                };
// 这里将awaitCommit添加到QueuedWork中的目的是为了退出activity时，确保所有数据已经全部同步到磁盘中了
            QueuedWork.addFinisher(awaitCommit);
​
            Runnable postWriteRunnable = new Runnable() {
                    @Override
                    public void run() {
                        awaitCommit.run();
                        // 数据同步完这里就会将awaitCommit从QueuedWork移除
                        QueuedWork.removeFinisher(awaitCommit);
                    }
                };
// 开始执行将数据同步到磁盘中，会新开线程，后面会说到
            SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
    // 这里是唤醒回调，前提是你注册了registerOnSharedPreferenceChangeListener()回调
    // 还有一个条件就是这个key是新添加的才会触发
            notifyListeners(mcr);
        }
​

apply的整个过程：首先将数据同步到内存，将内存中的数据全部同步到磁盘，如果没有同步完成，就会阻塞线程。

commit()
 @Override
        public boolean commit() {
            long startTime = 0;
​
            if (DEBUG) {
                startTime = System.currentTimeMillis();
            }
            //先将数据同步到内存，返回的是MermoryCommitResult对象
            MemoryCommitResult mcr = commitToMemory();
            // 开始执行将数据同步到磁盘中，会新开线程，这和前面的apply调用的相同的方法，参数不同。
            SharedPreferencesImpl.this.enqueueDiskWrite(
                mcr, null /* sync write on this thread okay */);
            try {
             // 进入等待状态, 直到写入文件的操作完成
                mcr.writtenToDiskLatch.await();
            } catch (InterruptedException e) {
                return false;
            } finally {
                if (DEBUG) {
                    Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration
                            + " committed after " + (System.currentTimeMillis() - startTime)
                            + " ms");
                }
            }
            //最终会调用onSharedPreferenceChanged方法
            notifyListeners(mcr);
            // 返回文件操作的结果
            return mcr.writeToDiskResult;
        }
​

这里会先判断是不是commit（）执行的，如果是commit（），那么就在当前线程中同步数据，这也就是为什么android现在不推荐使用这个方法了，如果是apply（）方法，那就还得往下看了，这里调用的是QueueWork这个类queue（），并将同步数据的任务传递进去，这里同步数据的工作就封装在writerDiskRunnable中，接下来看看queue（）里面是如何做的处理：

public static void queue(Runnable work, boolean shouldDelay) {
        Handler handler = getHandler();
​
        synchronized (sLock) {
            sWork.add(work);
    
            if (shouldDelay && sCanDelay) {
                handler.sendEmptyMessageDelayed(QueuedWorkHandler.MSG_RUN, DELAY);
            } else {
                handler.sendEmptyMessage(QueuedWorkHandler.MSG_RUN);
            }
        }
    }

先获取到一个handler，然后将同步数据的任务添加到了sWork这个集合中，那后面处理肯定也是去这个集合里面拿了，重点看这个getHandler（）：

 private static Handler getHandler() {
        synchronized (sLock) {
            if (sHandler == null) {
                HandlerThread handlerThread = new HandlerThread("queued-work-looper",
                        Process.THREAD_PRIORITY_FOREGROUND);
                handlerThread.start();
​
                sHandler = new QueuedWorkHandler(handlerThread.getLooper());
            }
            return sHandler;
        }
    }
    *----------------------------------*
    private static class QueuedWorkHandler extends Handler {
        static final int MSG_RUN = 1;
    
        QueuedWorkHandler(Looper looper) {
            super(looper);
        }
    
        public void handleMessage(Message msg) {
            if (msg.what == MSG_RUN) {
                processPendingWork();
            }
        }
    }

这里就是构建一个handler，如果已经存在就直接返回了，不过这个handler处理消息是在子线程中执行的，要看明白这里，首先你得知道Handler和HandlerThread的原理，构建Handler在子线中处理消息时，一定要为他准备一个looper对象，否则是会有异常的，看这里的handleMessage()，将执行的逻辑交给了processPendingWork（），来看看：

private static void processPendingWork() {
        long startTime = 0;
​
        if (DEBUG) {
            startTime = System.currentTimeMillis();
        }
    
        synchronized (sProcessingWork) {
            LinkedList<Runnable> work;
    
            synchronized (sLock) {
            // 将前面添加的任务全部clone出来，然后清除
                work = (LinkedList<Runnable>) sWork.clone();
                sWork.clear();
    
                // Remove all msg-s as all work will be processed now
   // 将任务取出来后，就可以取消后面执行任务的消息了，这里取消的只是上面clone出来的任务      
          getHandler().removeMessages(QueuedWorkHandler.MSG_RUN);
            }
​
            if (work.size() > 0) {
                for (Runnable w : work) {
                    w.run();
                }
    
                if (DEBUG) {
                    Log.d(LOG_TAG, "processing " + work.size() + " items took " +
                            +(System.currentTimeMillis() - startTime) + " ms");
                }
            }
        }
    }

这里执行的逻辑就是将前面添加的数据clone出来作为局部变量，然后将clone的集合清空，再移除发送任务的消息（这个任务已经添加到集合中了），这样数据同步就在子线程中完成了。到这，主要的逻辑都捋了一遍，但是还有一个点，退出activity时，数据没同步完是会阻塞线程的，现在就看看为什么会阻塞线程？这里要先知道一点，Activity生命周期都是通过ActivityThread来控制的，在ActivityThread的handleStopActivity方法中，这里控制的就是Activity的stop，在这个方法中有调用到：

QueuedWork.waitToFinish();

这里就是查看QueuedWork中的任务是否都执行完了，如果没有执行完，那么就会处于等待状态，看下它里面是一个怎样的逻辑：

    public static void waitToFinish() {
        long startTime = System.currentTimeMillis();
        boolean hadMessages = false;
     
        Handler handler = getHandler();
        // 先看下Handler中是否还有等待的消息，如果有那么就移除
        synchronized (sLock) {
            if (handler.hasMessages(QueuedWorkHandler.MSG_RUN)) {
                // Delayed work will be processed at processPendingWork() below
                handler.removeMessages(QueuedWorkHandler.MSG_RUN);
     
                if (DEBUG) {
                    hadMessages = true;
                    Log.d(LOG_TAG, "waiting");
                }
            }
     
            // We should not delay any work as this might delay the finishers
            sCanDelay = false;
        }
     
        StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
        try {
            // 这里就是将本该在子线程中执行的任务直接拿到主线程中来执行了
            processPendingWork();
        } finally {
            StrictMode.setThreadPolicy(oldPolicy);
        }
     
        try {
            // 这里是为了确保所有的任务确实已经执行完了
            while (true) {
                Runnable finisher;
     
                synchronized (sLock) {
                    finisher = sFinishers.poll();
                }
     
                if (finisher == null) {
                    break;
                }
     
                finisher.run();
            }
        } finally {
            sCanDelay = true;
        }
     
        synchronized (sLock) {
            long waitTime = System.currentTimeMillis() - startTime;
     
            if (waitTime > 0 || hadMessages) {
                mWaitTimes.add(Long.valueOf(waitTime).intValue());
                mNumWaits++;
     
                if (DEBUG || mNumWaits % 1024 == 0 || waitTime > MAX_WAIT_TIME_MILLIS) {
                    mWaitTimes.log(LOG_TAG, "waited: ");
                }
            }
        }
    }
这里会判断添加的任务是否全部执行完了，如果没有执行完，那么就会将本该在子线程中执行的任务全部移到主线程中来执行。

调用apply（）或commit（）方法将临时集合中的数据合并到mMap集合中并同步到磁盘中；以上大概就是Shared Preference源码详解；更多有关Android知识学习，大家可以参考传送直达↓↓↓ ：link.juejin.cn/?target=htt…这个技术文档会有你想要的。

总结:

1.sp数据都保存在内存缓存mMap中，缓存路径为data/data/packagename/shared_prefs，这样也就说明sp文件不适合存储大数据，会十分浪费内存。

2.apply()写入文件操作是异步执行的，不会占用主线程资源。先保存到内存，再通过异步线程保存sp文件到磁盘，commit保存到内存跟磁盘是同步保存，所以，如果频繁保存数据的话，apply肯定要高效,优先推荐使用apply。commit（）有返回值，apply（）没有返回值，apply（）失败了是不会报错的。保存数据时，apply（）是先将数据保存到内存中，然后在子线程中将数据更新到磁盘，commit（）是将数据保存到内存中，之后立即将数据同步到磁盘，这个操作是在当前线程中完成的，所以会阻塞线程，所以现在android建议使用apply（），但是使用apply（）时也有需要注意的地方，如果保存数据时这个过程还没有结束，但是这时退出了activity，这时activity会先确保数据是否已经全部同步到磁盘了，如果没有，这时会两种情况，一是保存的过程正在子线中执行，这时等待就好，如果这时还没分发给子线程，那么就直接切换到主线程执行了，所以这时提交数据时也有需要注意的地方，使用SharedPreferences.Editor提交数据时，尽量在所有数据都提交后再调用apply（）方法；

3.从sp中读取数据，需要等sp构造方法调用从磁盘读取数据成功后才继续往下执行，所以为了不造成阻塞，我们可以提前创建出SharedPreferences对象，而不是在使用的时候再去创建。