Android source code advanced in-depth understanding of the SharedPreference principle mechanism

[[429060]]

Preface

It's been a long time since I analyzed the source code. Today we will analyze SharedPreferences;

Let's learn together;

1. Simple use of SharedPreferences

1. Create

The first parameter is the name of the stored XML file, and the second is the opening method. Generally,

 Context.MODE_PRIVATE;
 SharedPreferences sp=context.getSharedPreferences( "name" , Context.MODE_PRIVATE);

2. Write

 //You can create a new SharedPreference to operate on the stored files
 SharedPreferences sp=context.getSharedPreferences( "name" , Context.MODE_PRIVATE);
 //Writing data in SharedPreference requires using Editor
 SharedPreference.Editor editor = sp.edit();
 //Similar to key-value pairs
 editor.putString( "name" , "string" );
 editor.putInt( "age" , 0);
 editor.putBoolean( "read" , true );
 //editor.apply();
 editor.commit ();

• Both apply and commit are used to submit and save data. The difference is that apply is executed asynchronously and does not require waiting. Regardless of deletion, modification, or addition, apply or commit must be called to submit and save data.
• About update: If the inserted key already exists, then the original key will be updated;
• Once the application is uninstalled, the SharedPreference will also be deleted;

3. Read

 SharedPreference sp=context.getSharedPreferences( "name" , Context.MODE_PRIVATE);
 //The first parameter is the key name, the second is the default value
 String name =sp.getString( "name" , "None" );
 int age=sp.getInt( "age" , 0);
 boolean read =sp.getBoolean( "isRead" , false );

4. Search

 SharedPreferences sp=context.getSharedPreferences( "name" , Context.MODE_PRIVATE);
 // Check if the current key exists
 boolean isContains=sp. contains ( "key" );
 //Use getAll to return all available key values
 //Map<String,?> allMaps=sp.getAll();

5. Delete

When we want to clear the data in SharedPreferences, we must first clear() and then commit(). We cannot delete the xml file directly.

 SharedPreference sp=getSharedPreferences( "name" , Context.MODE_PRIVATE);
 SharedPrefence.Editor editor=sp.edit();
 editor.clear();
 editor.commit ();

• getSharedPreference() does not generate files, which everyone knows;
• After deleting the file, execute commit() again, the deleted file will be regenerated, and the data of the regenerated file will be the same as before the deletion;
• After deleting the file, the content stored in the Preferences object remains unchanged unless the program is completely exited or stopped. Although the file is gone, the data still exists. The data will be lost only after the program is completely exited or stopped.
• To clear SharedPreferences data, you must execute editor.clear() and editor.commit(). You cannot simply delete the file. This is the final conclusion. Things to note

2. SharedPreferences source code analysis

1. Create

 SharedPreferences preferences = getSharedPreferences( "test" , Context.MODE_PRIVATE);

In fact, the real implementation class of context is ContextImp, so go to the getSharedPreferences method of ContextImp to view:

 @Override
 public SharedPreferences getSharedPreferences(String name , int mode) {
 ......
 File file;
       synchronized (ContextImpl.class) {
           if (mSharedPrefsPaths == null ) {
 //Define type: ArrayMap<String, File> mSharedPrefsPaths;
               mSharedPrefsPaths = new ArrayMap<>();
 }
 //Can we get the file from mSharedPrefsPaths?
           file = mSharedPrefsPaths.get( name );
 if (file == null ) { //If the file is null  
 //Create the file
               file = getSharedPreferencesPath( name );
 Store the name , file key-value pair in the collection
               mSharedPrefsPaths.put( name , file);
 }
 }
 return getSharedPreferences(file, mode);
 }

ArrayMap<String, File> mSharedPrefsPaths; The object is used to store the SharedPreference file name and the corresponding path. The path is obtained in the following method, that is, to obtain the directory data/data/package name/shared_prefs/

 @Override
 public File getSharedPreferencesPath(String name ) {
 return makeFilename(getPreferencesDir(), name + ".xml" );
 }
 private File getPreferencesDir() {
        synchronized (mSync) {
            if (mPreferencesDir == null ) {
                mPreferencesDir = new File(getDataDir(), "shared_prefs" );
 }
 return ensurePrivateDirExists(mPreferencesDir);
 }
 }

Object creation starts after the path

 @Override
 public SharedPreferences getSharedPreferences(File file, int mode) {
 //Key point 1
 checkMode(mode);
 .......
      SharedPreferencesImpl sp;
      synchronized (ContextImpl.class) {
 //Get the cache object (or create a cache object)
          final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
 //Get the Sp object from the cache object through the key file
          sp = cache.get(file);
 //If it is null , it means that there is no sp object for the file in the cache yet
 if (sp == null ) {
 //Key 2: Read files from disk
              sp = new SharedPreferencesImpl(file, mode);
 //Add to memory
              cache.put(file, sp);
 //Return sp
 return sp;
 }
 }
 //If set to MODE_MULTI_PROCESS mode, the SP's startReloadIfChangedUnexpectedly method will be executed.
      if ((mode & Context.MODE_MULTI_PROCESS) != 0 ||
          getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) {
          sp.startReloadIfChangedUnexpectedly();
 }
 return sp;
 }

It is to overload the previous method, but the input parameter is changed from file name to File, the creation process is locked synchronized, and all package names and corresponding files stored in the system are obtained through the method getSharedPreferencesCacheLocked(). This is why each sp file has only one corresponding SharedPreferencesImpl implementation object

process:

• Get the cache area, get data from the cache area, see if there is an sp object, and return it directly if it exists
• If it does not exist, then get the data from disk.
• After the data is retrieved from disk, it is added to memory.
• return sp;

getSharedPreferencesCacheLocked

 private ArrayMap<File, SharedPreferencesImpl> getSharedPreferencesCacheLocked() {
        if (sSharedPrefsCache == null ) {
            sSharedPrefsCache = new ArrayMap<>();
 }
        final String packageName = getPackageName();
        ArrayMap<File, SharedPreferencesImpl> packagePrefs = sSharedPrefsCache.get(packageName);
        if (packagePrefs == null ) {
            packagePrefs = new ArrayMap<>();
            sSharedPrefsCache.put(packageName, packagePrefs);
 }
 return packagePrefs;
 }

• In the getSharedPreferences(File file, int mode) method, get the SharedPreferencesImpl object from the file in the system cache above. If it has not been used before, you need to create an object through the method checkMode(mode);
• First check whether the mode is one of the three modes, then pass sp = new SharedPreferencesImpl(file, mode);
• Create an object and put it into the system's packagePrefs for easy access later;

 SharedPreferencesImpl(File file, int mode) {
 mFile = file; //Store file
 //Backup file (disaster recovery file)
        mBackupFile = makeBackupFile(file);
        //model
 mMode = mode;
 //Has it been loaded?
 mLoaded = false ;
 //Store key-value pair information in the file
 mMap = null ;
 //From the name, you can know that it starts loading data from disk
 startLoadFromDisk();
 }

• Mainly, several parameters are set. mFile is the original file; mBackupFile is the backup file with the suffix .bak;
• mLoaded indicates whether the modified file is being loaded;
• mMap is used to store data in sp files. It is also stored in the form of key-value pairs and is also obtained through this method. This means that every time sp is used, data is written to memory. This is why sp data stores data quickly. Therefore, sp files cannot store large amounts of data, otherwise it will easily cause OOM during execution.
• mThrowable reports errors when loading files;
• The following is the method for loading data startLoadFromDisk(); load data from the sp file into mMap

2. startLoadFromDisk()

 private void startLoadFromDisk() {
 synchronized (mLock) {
 mLoaded = false ;
 }
 //Start the child thread to load disk data
       new Thread( "SharedPreferencesImpl-load" ) {
 public void run() {
               loadFromDisk();
 }
 }.start();
 }
   private void loadFromDisk() {
 synchronized (mLock) {
 //If it has been loaded, return directly
 if (mLoaded) {
 return ;
 }
 //Whether the backup file exists,
           if (mBackupFile.exists()) {
 //Delete the original file
               mFile.delete ();
 //Name the backup file: xml file
               mBackupFile.renameTo(mFile);
 }
 }
 .......
 Map map = null ;
       StructStat stat = null ;
 try {
 //The following is to read the data
           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 (Exception e) {
                   Log.w(TAG, "Cannot read " + mFile.getAbsolutePath(), e);
 finally
                   IoUtils.closeQuietly(str);
 }
 }
       } catch (ErrnoException e) {
 /* ignore */
 }
 synchronized (mLock) {
 //Loading completed,
 mLoaded = true ;
 //The data is not null  
           if (map != null ) {
 //Assign map to the global mMap object that stores file key-value pairs
 mMap = map;
 //Update memory modification time and file size
               mStatTimestamp = stat.st_mtime;
               mStatSize = stat.st_size;
 } else {
               mMap = new HashMap<>();
 }
 //Key point: wake up all waiting threads locked with mLock
 mLock.notifyAll();
 }
 }

• First, determine whether the backup file exists. If it does, change the suffix of the backup file. Then start reading the data, assign the read data to the mMap object of the global variable storage file key-value pair, and update the modification time and file size variables.
• Wake up all waiting threads that use mLock as lock;
• So far, the initialization of the SP object has been completed. In fact, it can be seen that it is a secondary cache process: disk to memory;

3. Get the key-value pairs in SP

 @Nullable
 public String getString(String key , @Nullable String defValue) {
 synchronized (mLock) { lock judgment
 awaitLoadedLocked(); //Waiting mechanism
 String v = (String)mMap.get( key ); //Get data from the key-value pair
 return v != null ? v : defValue;
 }
 }
 private void awaitLoadedLocked() {
 .......
 while (!mLoaded) { //When the data is loaded, the value is true  
 try {
 //Thread waiting
 mLock.wait();
           } catch (InterruptedException unused) {
 }
 }
 }

If the data has not been loaded (that is, mLoaded=false), the thread will wait;

4. putXXX and apply source code

 public Editor edit() {
 //Same principle as getXXX
        synchronized (mLock) {
            awaitLoadedLocked();
 }
 //Return the EditorImp object
 return new EditorImpl();
 }
 public Editor putBoolean(String key , boolean value) {
 synchronized (mLock) {
           mModified.put( key , value);
 return this;
 }
 }
 public void apply() {
            final long startTime = System.currentTimeMillis();
 //According to the name, we can know: submit data to memory
            final MemoryCommitResult mcr = commitToMemory();
 ........
 //Commit data to disk
            SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
 //Key point: calling listener
            notifyListeners(mcr);
 }

• First, commitToMemory is executed to commit the data to memory; then the data is committed to disk;
• Then the listener is called;

5. commitToMemory

     private MemoryCommitResult commitToMemory() {
            long memoryStateGeneration;
            List<String> keysModified = null ;
 Set <OnSharedPreferenceChangeListener> listeners = null ;
 //Write the data set to disk
            Map<String, Object> mapToWriteToDisk;
            synchronized (SharedPreferencesImpl.this.mLock) {
                if (mDiskWritesInFlight > 0) {
                    mMap = new HashMap<String, Object>(mMap);
 }
 //Assign the cache collection to mapToWriteToDisk
                mapToWriteToDisk = mMap;
 .......
                synchronized (mLock) {
                    boolean changesMade = false ;
 //Key point: whether to clear the data
                    if (mClear) {
                        if (!mMap.isEmpty()) {
                            changesMade = true ;
 // Clear the key-value pair information in the cache
                            mMap.clear();
 }
                        mClear = false ;
 }
 //Loop mModified and update the data in mModified to mMap
 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 ;
                                }
 }
 //Note: At this time, the key-value pair information is written into the cache collection
                            mMap.put(k, v);
 }
 .........
 }
 // Clear the temporary collection
                    mModified.clear();
 ......
 }
 }
 return new MemoryCommitResult(memoryStateGeneration, keysModified, listeners,
                    mapToWriteToDisk);
 }

• mModified is the key-value pair collection we want to update and add this time;
• mClear is assigned when we call the clear() method;
• The general process is: first determine whether the memory data needs to be cleared, then loop the mModified collection and add the updated data to the key-value pair collection in the memory;

6. Commit method

 public boolean commit () {
 .......
 //Update data to memory
           MemoryCommitResult mcr = commitToMemory();
 // Update data to disk
           SharedPreferencesImpl.this.enqueueDiskWrite(
               mcr, null /* sync write on this thread okay */);
 try {
 //Wait: Wait for the disk to update data
               mcr.writtenToDiskLatch.await();
           } catch (InterruptedException e) {
 return   false ;
 finally
 if (DEBUG) {
                   Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration
                           + " committed after " + (System.currentTimeMillis() - startTime)
                           + "ms" );
 }
 }
 //Execute listener callback
           notifyListeners(mcr);
 return mcr.writeToDiskResult;
 }

• First, apply has no return value, but commit does.
• In fact, the apply method executes the callback in parallel with the data being written to disk, while the commit method executes the callback after the disk writing is completed;

3. Detailed explanation of QueuedWork

1. QueuedWork

The QueuedWork class is used after the initialization of sp. As we have seen before, both the apply and commit methods are implemented through QueuedWork.

QueuedWork is a management class. As the name implies, it has a queue that manages and schedules all queued work.

The most important thing is to have a HandlerThread

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

2. Join the queue

 // If it is a commit , it cannot be delayed, if it is an apply, it can be delayed
 public   static void queue(Runnable work , boolean shouldDelay) {
       Handler handler = getHandler();
 synchronized (sLock) {
           sWork.add ( work );
           if (shouldDelay && sCanDelay) {
 // The default delay time is 100ms
               handler.sendEmptyMessageDelayed(QueuedWorkHandler.MSG_RUN, DELAY);
 } else {
               handler.sendEmptyMessage(QueuedWorkHandler.MSG_RUN);
 }
 }
 }

3. Message processing

 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();
 }
 }
 }
   private static void processPendingWork() {
       synchronized (sProcessingWork) {
           LinkedList<Runnable> work ;
           synchronized (sLock) {
 work = (LinkedList<Runnable>) sWork.clone();
 sWork.clear();
               getHandler().removeMessages(QueuedWorkHandler.MSG_RUN);
 }
           if ( work . size () > 0) {
 for (Runnable w : work ) {
 w.run();
 }
 }
 }
 }

• As you can see, the scheduling is very simple. There is an sWork inside, which iterates through all runnables when it needs to be executed;
• For the apply operation, there will be a certain delay before the work is executed, but for the commit operation, the scheduling will be triggered immediately, and not only the task passed by the commit will be scheduled, but all the work in the queue will be scheduled immediately;

4. waitToFinish

Many places in the system will wait for the sp to finish writing files, and the waiting method is to call QueuedWork.waitToFinish();

 public   static void waitToFinish() {
      Handler handler = getHandler();
 synchronized (sLock) {
 // Remove all messages and start scheduling all work directly  
          if (handler.hasMessages(QueuedWorkHandler.MSG_RUN)) {
              handler.removeMessages(QueuedWorkHandler.MSG_RUN);
 }
 sCanDelay = false ;
 }
      StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
 try {
 // If waitToFinish is called, all work will be executed immediately  
          processPendingWork();
 finally
          StrictMode.setThreadPolicy(oldPolicy);
 }
 try {
 // After all work is completed, you need to execute Finisher
 // In the previous apply step, there is a step of QueuedWork.addFinisher(awaitCommit);
 // The implementation is to wait for the sp file to be written
 // If it is not scheduled through msg but through waitToFinish, the runnable will be executed here
 while ( true ) {
              Runnable finisher;
              synchronized (sLock) {
                  finisher = sFinishers.poll();
 }
              if (finisher == null ) {
 break;
 }
 finisher.run();
 }
 finally
 sCanDelay = true ;
 }
 ...
 }

The processing logic of the four major components in the system is implemented in ActivityThread. During the execution of the service/activity life cycle, it will wait for the sp to be written. It is by calling QueuedWork.waitToFinish() that the app data is correctly written to disk;

5. Suggestions for using sp

• The real-time requirements for data are not high, so try to use apply
• If the business requires that the data must be written successfully, use commit
• Reduce the frequency of sp operations and try to write all data in one commit
• You may consider not accessing sp in the main thread.
• The data written to sp should be as lightweight as possible

Summarize:

The implementation of SharedPreferences itself is divided into two steps, one is memory and the other is disk, and the main thread depends on the writing of SharedPreferences. So when io becomes a bottleneck, the App may become stuck because of SharedPreferences, and in severe cases, ANR may occur. To sum up, there are the following points:

• The data stored in the XML file will be loaded into the memory, so the data can be retrieved quickly.
• Apply is an asynchronous operation, which submits data to memory and does not immediately submit it to disk.
• Commit is a synchronous operation, which will wait for the data to be written to disk and return the result.
• If the same thread commits multiple times, the subsequent ones must wait for the previous ones to finish executing.
• If multiple threads commit to the same sp concurrently, all subsequent tasks will enter the QueuedWork queue for execution and must wait until the first task is completed.

This article is reproduced from the WeChat public account "Android Development Programming"

【Editor's recommendation】

1. How to upgrade from Windows 10 to Windows 11 for free?
2. Windows 11 is officially released! Installation method and ISO image download are all here
3. Breaking news! Apple officially shuts down iOS 14.8 verification system
4. Have you upgraded? Windows 11 official version is 40% smaller
5. Have you updated Windows 11? Why haven't I received any notifications yet?