今天使用SharedPreferences的时候突然想到了这个问题，因为我们要存储应用级别的上下文信息，包括用户信息等一系列信息；这个时候使用getSharedPreferences是否合适呢！
其实这个问题是相对的 ，如果存储少量信息那么使用getSharedPreferences确实是非常便捷的，如果要存储大量的信息那么尽量不要使用SharedPreferences。
首先探讨SharedPreferences这个问题的时候我们先来分析下Context，Context什么意思呢!顾名思义是“上下文”的含义；那么兄弟们又要喷水了，和没有解释一样；哈哈
如果说整个android环境是一个“软件”公司的话，那么我可以把android中的Context比喻成“项目研发团队”，那么其中的android四大组件以甚至可以说成是6大件或者7大件（包含intent，Notification等），就相当于“项目团队”中的->攻城狮，他们各司其职。而且 ，这样比喻你可以体会到，在整个android的环境中我们的activity或者service并不是可以你说new就new的，因为招聘什么样的“攻城狮”是组织才能决定的；和j2ee很不相似。
好啦！闲话少叙言归正传；那么SharedPreferences是和Context密不可分的。Context在application启动时，由Native层给予；而且同学们也都知道Context是一个抽象的，它的具体实现在哪里呢？而且ContextWapper也是要通过attachBaseContext之后才能获得一个mBase实例。
/**
* Set the base context for this ContextWrapper. All calls will then be
* delegated to the base context. Throws
* IllegalStateException if a base context has already been set.
*
* @param base The new base context for this wrapper.
*/
protected void attachBaseContext(Context base) {
if (mBase != null) {
throw new IllegalStateException("Base context already set");
}
mBase = base;
}
实际上Native中将一个叫做ContextImpl的类型给予了ContextWapper。这样我们就可以在ContextImpl类型中去寻找SharedPreferences的足迹，因为SharedPreferences是通过上下文Context来获得的！让我们直接上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 = new ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>>();为核心；最后返回的是sp，细节如下：
if (sp == null) {
File prefsFile = getSharedPrefsFile(name);
sp = new SharedPreferencesImpl(prefsFile, mode);
packagePrefs.put(name, sp);
return sp;
}
注意标红的类型，这一步骤将File prefsFile = getSharedPrefsFile(name);获得到的文件传入了构造方法中！！！其实如果文件不存在的话getSharedPrefsFile也是在new File();
那么关键的地方就在于SharedPreferencesImpl这个类。
它的构造函数如下：
SharedPreferencesImpl(File file, int mode) {
mFile = file;
mBackupFile = makeBackupFile(file);
mMode = mode;
mLoaded = false;
mMap = null;
startLoadFromDisk();
}
private void startLoadFromDisk() {
synchronized (this) {
mLoaded = false;
}
new Thread("SharedPreferencesImpl-load") {
public void run() {
synchronized (SharedPreferencesImpl.this) {
loadFromDiskLocked();
}
}
}.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 = 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();
}
拔山涉水之后讨论的关键渐渐的浮现出来：依旧注意标红。HashMap就是当存储内容过大时准备放弃使用SharedPreferences的缘故，相信走到这里的同学已经明白了。当我们第一次使用
getSharedPreferences的时候它就会把你存储的内容注入内存中一直保留！！所以说我们使用过多的Key，Value存储时，可以尝试使用java中的Properties等方式。
这样就已经豁然开朗，好！我们继续。使用SharedPreferences获取数据时的实际方法在这，包括edit的操作：
public int getInt(String key, int defValue) {
synchronized (this) {
awaitLoadedLocked();
Integer v = (Integer)mMap.get(key);
return v != null ? v : defValue;
}
}
public long getLong(String key, long defValue) {
synchronized (this) {
awaitLoadedLocked();
Long v = (Long)mMap.get(key);
return v != null ? v : defValue;
}
}
public float getFloat(String key, float defValue) {
synchronized (this) {
awaitLoadedLocked();
Float v = (Float)mMap.get(key);
return v != null ? v : defValue;
}
}
public boolean getBoolean(String key, boolean defValue) {
synchronized (this) {
awaitLoadedLocked();
Boolean v = (Boolean)mMap.get(key);
return v != null ? v : defValue;
}
}
我们已经发现他一直是在从缓存的HashMap中提取值，拿给我们！还有我们熟悉的commit()方法都在SharedPreferencesImpl类型中；顺便说下apply为异步操作，commit为同步IO操作，耗时可能会比较长。commit代码如下：
public boolean commit() {
MemoryCommitResult mcr = commitToMemory();
SharedPreferencesImpl.this.enqueueDiskWrite(
mcr, null /* sync write on this thread okay */);//by zzq 写入文件
try {
mcr.writtenToDiskLatch.await();//by zzq 同步等待
} catch (InterruptedException e) {
return false;
}
notifyListeners(mcr);//by zzq 通知，监听者
return mcr.writeToDiskResult;
}
commitToMemory这个方法中会将提交进来的新key，value一直做put或update操作到名为mMap的HashMap中。
private MemoryCommitResult commitToMemory() {
MemoryCommitResult mcr = new MemoryCommitResult();
synchronized (SharedPreferencesImpl.this) {
// We optimistically don't make a deep copy until
// a memory commit comes in when we're already
// writing to disk.
if (mDiskWritesInFlight > 0) {
// 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);
}
mcr.mapToWriteToDisk = mMap;
mDiskWritesInFlight++;
boolean hasListeners = mListeners.size() > 0;
if (hasListeners) {
mcr.keysModified = new ArrayList<String>();
mcr.listeners =
new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
}
synchronized (this) {
if (mClear) {
if (!mMap.isEmpty()) {
mcr.changesMade = true;
mMap.clear();
}
mClear = false;
}
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);
}
mcr.changesMade = true;
if (hasListeners) {
mcr.keysModified.add(k);
}
}
mModified.clear();
}
}
return mcr;
}
apply同样调用以上方法！