@Override
public SharedPreferences getSharedPreferences(File file, int mode) {
	checkMode(mode);
	SharedPreferencesImpl sp;
	synchronized (ContextImpl.class) {
		final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
		sp = cache.get(file);
		if (sp == null) {
			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;
}

    void startReloadIfChangedUnexpectedly() {
        synchronized (this) {
            // TODO: wait for any pending writes to disk?
            if (!hasFileChangedUnexpectedly()) {
                return;
            }
            startLoadFromDisk();
        }
    }

final class SharedPreferencesImpl implements SharedPreferences {
	...
	public final class EditorImpl implements Editor {
		...
		private MemoryCommitResult commitToMemory() {
			...
		}
		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;
		}
	}

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

public class SPHelper {
	...

    public static final String CONTENT="content://";
    public static final String AUTHORITY="com.pl.sphelper";
    public static final String SEPARATOR= "/";
    public static final String CONTENT_URI =CONTENT+AUTHORITY;
    public static final String TYPE_INT="int";
	public static final String NULL_STRING= "null";

	public static int getInt(String name, int defaultValue) {
        ContentResolver cr = context.getContentResolver();
        Uri uri = Uri.parse(CONTENT_URI + SEPARATOR + TYPE_INT + SEPARATOR + name);
        String rtn = cr.getType(uri);
        if (rtn == null || rtn.equals(NULL_STRING)) {
            return defaultValue;
        }
        return Integer.parseInt(rtn);
    }
	...
}

public class SPContentProvider extends ContentProvider{
	...
    public static final String SEPARATOR= "/";

	public String getType(Uri uri) {
        // 用这个来取数值
        String[] path= uri.getPath().split(SEPARATOR);
        String type=path[1];
        String key=path[2];
        return  ""+SPHelperImpl.get(getContext(),key,type);
    }
	...
}

class SPHelperImpl {
	...

    public static final String TYPE_INT="int";

    static String get(Context context, String name, String type) {
        if (type.equalsIgnoreCase(TYPE_STRING)) {
			return getString(context, name, null);
		} else if (type.equalsIgnoreCase(TYPE_BOOLEAN)) {
			return getBoolean(context, name, false);
		} else if (type.equalsIgnoreCase(TYPE_INT)) {
			return getInt(context, name, 0);
		} else if (type.equalsIgnoreCase(TYPE_LONG)) {
			return getLong(context, name, 0L);
		} else if (type.equalsIgnoreCase(TYPE_FLOAT)) {
			return getFloat(context, name, 0f);
		} else if (type.equalsIgnoreCase(TYPE_STRING_SET)) {
			return getString(context, name, null);
		}
		return null;
    }

    static int getInt(Context context, String name, int defaultValue) {
        SharedPreferences sp = getSP(context);
        if (sp == null) return defaultValue;
        return sp.getInt(name, defaultValue);
    }
	...
}

private static SoftReference<Map<String, Object>> sCacheMap;

private static Object getCachedValue(String name) {
	if (sCacheMap != null) {
		Map<String, Object> map = sCacheMap.get();
		if (map != null) {
			return map.get(name);
		}
	}
	return null;
}

private static void setValueToCached(String name, Object value) {
	Map<String, Object> map;
	if (sCacheMap == null) {
		map = new HashMap<>();
		sCacheMap = new SoftReference<Map<String, Object>>(map);
	} else {
		map = sCacheMap.get();
		if (map == null) {
			map = new HashMap<>();
			sCacheMap = new SoftReference<Map<String, Object>>(map);
		}
	}
	map.put(name, value);
}
synchronized static <T> void save(Context context, String name, T t) {
	SharedPreferences sp = getSP(context);
	if (sp == null) return;

	if (t.equals(getCachedValue(name))) {
		return;
	}
	SharedPreferences.Editor editor = sp.edit();
	if (t instanceof Boolean) {
		editor.putBoolean(name, (Boolean) t);
	}
	if (t instanceof String) {
		editor.putString(name, (String) t);
	}
	if (t instanceof Integer) {
		editor.putInt(name, (Integer) t);
	}
	if (t instanceof Long) {
		editor.putLong(name, (Long) t);
	}
	if (t instanceof Float) {
		editor.putFloat(name, (Float) t);
	}
	editor.commit();
	setValueToCached(name, t);
}

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
    @Test
    public void useAppContext() throws Exception {
		Context appContext = InstrumentationRegistry.getTargetContext();
		SPHelper.init((Application) appContext.getApplicationContext());
		Random random = new Random();
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100; i++) {
			SPHelper.save("key" + random.nextInt(200), i);
		}
		long end = System.currentTimeMillis();
		Log.e("ExampleInstrumentedTest", "SPHelper takes " + (end - start) + "millis");

		start = System.currentTimeMillis();
		for (int i = 0; i < 100; i++) {
			SharedPreferences sp = appContext.getSharedPreferences("text", Context.MODE_PRIVATE);
			SharedPreferences.Editor editor = sp.edit();
			editor.putInt("key" + random.nextInt(200), i);
			editor.commit();
		}
		end = System.currentTimeMillis();
		Log.e("ExampleInstrumentedTest", "SharedPreferences takes " + (end - start) + "millis");
    }
}