SharePreferences性能编程

可能大家知道SharePerfence也是Android存储数据的一种方式,但是他只能存储键值对,内部实现时候利用创建一个xml文件实现。但有几个问题是值得需要注意下

SharePerfence能存储多大的数据。
SharePerfence.Edit的commit和apply方法的区别。

1、读取数据

1.1、ContextImpl.getSharePerfence()

public SharedPreferences getSharedPreferences(File file, int mode) {
    SharedPreferencesImpl sp;
    synchronized (ContextImpl.class) {
        //获取当前缓存的SharedPreferencesImpl实例
        final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
        sp = cache.get(file);
        if (sp == null) {
            //检测操作该文件的方式
            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");
                }
            }
            //创建SharedPreferences的实现类并将其缓存起来
            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) {
        sp.startReloadIfChangedUnexpectedly();
    }
    return sp;
}

1.2、SharedPreferencesImpl()

  SharedPreferencesImpl(File file, int mode) {
    mFile = file;
    mBackupFile = makeBackupFile(file);
    mMode = mode;
    mLoaded = false;
    mMap = null;
    mThrowable = null;
    //开始加载文件并解析xml
    startLoadFromDisk();
}

-> SharedPreferencesImpl.startLoadFromDisk()

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

-> SharedPreferencesImpl.loadFromDisk()

  private void loadFromDisk() {
    synchronized (mLock) {
        if (mLoaded) {
            return;
        }
        if (mBackupFile.exists()) {
            mFile.delete();
            mBackupFile.renameTo(mFile);
        }
    }
    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);
                //解析xml文件获取相应的键值对
                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;
    }
    //省略部分代码
}

通过以上加载xml文件可知,先通过解析xml获取相应的键值对存放在ArrayMap中,需要注意的是这个是放在内存中,若存放的数据比较大的话相应的这部分占用的的内存也会比较大。这内存优化的时候需要注意这一点。

2、存储数据

2.1、SharedPreferencesImpl.EditImpl()

 public final class EditorImpl implements Editor {
    private final Object mEditorLock = new Object();
    @GuardedBy("mEditorLock")
    private final Map<String, Object> mModified = new HashMap<>();

    @GuardedBy("mEditorLock")
    private boolean mClear = false;

    @Override
    public Editor putString(String key, @Nullable String value) {
        synchronized (mEditorLock) {
            mModified.put(key, value);
            return this;
        }
    }
    //省略部分代码
    }

存储数据的逻辑比较简单将key/value直接放置在hashMap中。

2.2、EditImpl.commit()

  @Override
    public boolean commit() {
        long startTime = 0;

        MemoryCommitResult mcr = commitToMemory();
        //同步写入到文件中
        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");
            }
        }
        //回调数据改变监听
        notifyListeners(mcr);
        return mcr.writeToDiskResult;
    }

代码比较简单同步写入数据。

2.3、EditorImpl.apply()

@Override
    public void apply() {
        final long startTime = System.currentTimeMillis();

        final MemoryCommitResult mcr = commitToMemory();
        final Runnable awaitCommit = new Runnable() {
                @Override
                public void run() {
                    try {
                        //等待写入完成
                        mcr.writtenToDiskLatch.await();
                    } catch (InterruptedException ignored) {
                    }
                }
            };

        QueuedWork.addFinisher(awaitCommit);
        Runnable postWriteRunnable = new Runnable() {
                @Override
                public void run() {
                    awaitCommit.run();
                    QueuedWork.removeFinisher(awaitCommit);
                }
            };

        SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
        notifyListeners(mcr);
    }

与commit方法不同的是这个方法的写入数据的方式是异步的。

3、总结

SharedPreferences存储的是方式是通过创建xml文件存放键值对来实现的。对数据的大小没有做限制,但是在获取数据时会将整个文件中的数据全部读取到内存中,所以建议不要存放占用内存很大的数据。通过Editor写入数据时,commit是同步方法会阻塞主线程而apply是异步写入不会阻塞。