SharedPreference

原理

创建

1. 创建sp文件的File对象

class ContextImpl {
	SharedPreferences getSP(String name, int mode) {
		...
		
		synchronzed (ContextImpl.class) {
			...
			file = mSharedPrefsPaths.get(name);
			if (file == null) {
				file = getSHaredPreferencesPath(name); //就是计算出默认sp文件的路径，用这个路径创建File
				mSharedPrefsPaths.put(name, file);
			}
		}
		// 获取sp
		return getSharedPreferences(file, mode);
	}
}

2. 创建sp对象

class ContextImpl {
	SP getSP(File file, int mode) {
		.
		synchronized (ComtextImpl.class) {
			..
			if (sp == null) {
				...
				sp = new SPImpl(file, mode); // 创建的地方
				cache.put(file, sp); // 有缓存的，上面省略了
				return sp;
			}
		}
	}
}

3. 创建时，如果文件存在，则异步解析到内存里

class SPImpl {
	SPImpl(File file, int mode) {
		...
		startLoadFromDisk(); // 新建线程，执行load操作
	}

	void loadFromDisk() {
		...
		
		try {
			if (mFile.canRead()) {
				.
				try {
					str = new BufferedInputStream(
						new FileInputStream(mFile),
						16*1026
						); // SP的文件
					map = (Map<String, Object>) XmlUtils.readMapXml(str); // 对 XmlPullParser 的封装，解析sp文件到内存里
				}
				
			}
		}

		synchronized (mLock) {
			..
			try {
				if () {
					if (map != null) {
						mMap = map; // 保存到成员变量
						...
					}
				}
			}
		}
	}
}

修改

获取EditorImpl 来执行修改操作

获取方法是 SPImpl.edit()

class SPImpl {
	Editor edit() {
		.
		return new EditorImpl();
	}
}

保存

1. 先把要保存的数据，保存到mModified 里

class SPImpl {
	class EditorImpl {
		Editor putString(String key, String value) {
			synchronized (mEditorLock) {
				mModified.put(key, value);
				return this;
			}
		}
		
	}
}

2. 调用apply() 或者 commit() 方法，把修改写入文件里

apply() 方法

1. toMemeory：就是把数据同步到内存里。在 commitToMemory() 方法里，已经把修改的数据 EditorImpl.mModified 同步到 SPImpl.mMap 里了
2. disk: 就是把数据写到文件里。调用 enqueueDiskWrite() 同步到disk 里

写到memory

class SPImpl {
	class EditorImpl {
		void apply() {
			.
			// 把要修改的数据，更新到mMap里，并用mMap生成 这个result
			MemoryCommitResult mcr = commitToMemory();
			
			Runnable awaitCommit = new Runnable() {
				void run() {
					mcr.writtenToDiskLatch.await(); // 是一个CountDownLatch，本质就是LockSupport.park()
				}
			};
			
			.
			
			// 这个Runnable 就是执行 CountDownLatch.await()。让线程park()
			Runnable postWriteRunnable = new Runnable() {
				void run() {
					awaitCommit.run();
					.
				}
			}
			
			// 主要是这个函数
			SPImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
			
			. // 分发listener的监听，不管
		}
	
		// 要修改的数据保存在mModified 里
		// 文件里的数据保存在mMap 里
		// 用 mModified 数据去修改 mMap里的数据，这样mMap就是修改后的数据了
		MemoryCommitResult commitToMemory() {
			...
			synchronized (SPImpl.this.class) {
				...
				
				mapToWriteToDisk = mMap;
				
				...
				
				synchronized (mEditorLock) {
					...
					
					for (Map.Entry<String, Object> e : mModified.entrySet()) {
						..
						if (v == this || v == null) { // 删除
							..
							mapToWriteToDisk.remove(k); // mapToWriteToDisk 是从文件读取出来的数据。这里是删除
						} else {
							... // 如果有相同的数据，则continue
							
							mapToWriteToDisk.put(k, v); 
						}
					}
				}
			}
			return new MemoryCommitResult(..., mapToWriteToDisk);
		}
	}
}

写到disk

1. “queued-work-looper” 线程中 把修改写入disk，并且执行countDown()
2. 写入disk 完成后，执行await()，因为已经执行countDown()了，所以没有park线程

class SPImpl {
	void enqueueDiskWrite(MemoryCommitResult mcr, Runnable postWriteRunnable) {
		
		.
		
		Runnable writeToDiskRunnable = new Runnable() {
			void run() {
				synchronized(mWriteToDiskLock) {
					// 写入disk
					writeToFile(mcr, isSync);
				}
				...
				
				if (postWriteRunnable != null) {
					postWriteRunnable.run(); // 执行 线程的park()
				}
			}
		}
		
		...
		
		// 放到名叫 "queued-work-looper" 的线程里运行writeToDiskRunnable
		QueueWork.queue(writeToDiskRunnable, !isSync);
	}
}

commit() 方法

class SPImpl {
	class EditorImpl {
		boolean commit() {
			...
			
			// 把修改同步到SPImpl.mMap 中，SPImpl.mMap 也保存到 mcr里
			MemoryCommitResult mcr = commitToMemory();
			
			// 在调用commit的线程里，执行写入disk的操作。
			SPImpl.this.enqueueDiskWrite(mcr, null);
			
			// 写入disk结束时，会设置 mcr.writeToDiskResult 是否写入成功
			return mcr.writeToDiskResult;
		}
	}
}