成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

源碼進階：騰訊開源輕量級緩存 Mmkv 源碼解析

作者： Android開發(fā)編程
存儲
MMKV 是基于 mmap 內存映射的 key-value 組件，底層序列化/反序列化使用 protobuf 實現(xiàn)，性能高，穩(wěn)定性強。

[[429938]]

本文轉載自微信公眾號「Android開發(fā)編程」，作者Android開發(fā)編程。轉載本文請聯(lián)系Android開發(fā)編程公眾號。

前言

MMKV本質上的定位和sp有點相似，經常用于持久化小數(shù)據的鍵值對;

其速度可以說是當前所有同類型中速度最快，性能最優(yōu)的庫;

今天我們就來聊聊;

一、MMKV介紹和簡單使用

1、什么是mmkv

MMKV 是基于 mmap 內存映射的 key-value 組件，底層序列化/反序列化使用 protobuf 實現(xiàn)，性能高，穩(wěn)定性強;

MMKV 基本原理

內存準備：通過 mmap 內存映射文件，提供一段可供隨時寫入的內存塊，App 只管往里面寫數(shù)據，由操作系統(tǒng)負責將內存回寫到文件，不必擔心 crash 導致數(shù)據丟失;

數(shù)據組織：數(shù)據序列化方面我們選用 protobuf 協(xié)議，pb 在性能和空間占用上都有不錯的表現(xiàn);

寫入優(yōu)化：考慮到主要使用場景是頻繁地進行寫入更新，我們需要有增量更新的能力，考慮將增量 kv 對象序列化后，append 到內存末尾;

空間增長：使用 append 實現(xiàn)增量更新帶來了一個新的問題，就是不斷 append 的話，文件大小會增長得不可控，我們需要在性能和空間上做個折中;

2、MMKV的使用

使用前請初始化：

  1. MMKV.initialize(this) 

mmkv寫入鍵值對;

  1. var mmkv = MMKV.defaultMMKV() 
  2. mmkv.encode("bool",true) 
  3. mmkv.encode("int",1) 
  4. mmkv.encode("String","test") 
  5. mmkv.encode("float",1.0f) 
  6. mmkv.encode("double",1.0) 

mmkv除了能夠寫入這些基本類型，只要SharePrefences支持的，它也一定能夠支持;

mmkv讀取鍵值對;

  1. var mmkv = MMKV.defaultMMKV() 
  2. var bo = mmkv.decodeBool("bool") 
  3. Log.e(TAG,"bool:${bo}") 
  4. var i = mmkv.decodeInt("int") 
  5. Log.e(TAG,"int:${i}") 
  6. var s = mmkv.decodeString("String") 
  7. Log.e(TAG,"String:${s}") 
  8. var f = mmkv.decodeFloat("float") 
  9. Log.e(TAG,"float:${f}") 
  10. var d = mmkv.decodeDouble("double") 
  11. Log.e(TAG,"double:$owocgsc") 

每一個key讀取的數(shù)據類型就是decodexxx對應的類型名字;

mmkv 刪除鍵值對和查鍵值對;

  1. var mmkv = MMKV.defaultMMKV() 
  2. mmkv.removeValueForKey("String") 
  3. mmkv.removeValuesForKeys(arrayOf("int","bool")) 
  4. mmkv.containsKey("String") 

能夠刪除單個key對應的value，也能刪除多個key分別對應的value;

containsKey判斷mmkv的磁盤緩存中是否存在對應的key;

二、MMKV 源碼解析

1、初始化

通過 MMKV.initialize 方法可以實現(xiàn) MMKV 的初始化：

  1. public static String initialize(Context context) { 
  2.     String root = context.getFilesDir().getAbsolutePath() + "/mmkv"; 
  3.     return initialize(root); 
  4. } 

它采用了內部存儲空間下的 mmkv 文件夾作為根目錄，之后調用了 initialize 方法;

  1. public static String initialize(String rootDir) { 
  2.     MMKV.rootDir = rootDir; 
  3.     jniInitialize(MMKV.rootDir); 
  4.     return rootDir; 
  5. } 

調用到了 jniInitialize 這個 Native 方法進行 Native 層的初始化：

  1. extern "C" JNIEXPORT JNICALL void 
  2. Java_com_tencent_mmkv_MMKV_jniInitialize(JNIEnv *env, jobject obj, jstring rootDir) { 
  3.     if (!rootDir) { 
  4.         return; 
  5.     } 
  6.     const char *kstr = env->GetStringUTFChars(rootDir, nullptr); 
  7.     if (kstr) { 
  8.         MMKV::initializeMMKV(kstr); 
  9.         env->ReleaseStringUTFChars(rootDir, kstr); 
  10.     } 
  11. } 

這里通過 MMKV::initializeMMKV 對 MMKV 類進行了初始化：

  1. void MMKV::initializeMMKV(const std::string &rootDir) { 
  2.     static pthread_once_t once_control = PTHREAD_ONCE_INIT; 
  3.     pthread_once(&once_control, initialize); 
  4.     g_rootDir = rootDir; 
  5.     char *path = strdup(g_rootDir.c_str()); 
  6.     mkPath(path); 
  7.     free(path); 
  8.     MMKVInfo("root dir: %s", g_rootDir.c_str()); 
  9. } 

實際上就是記錄下了 rootDir 并創(chuàng)建對應的根目錄，由于 mkPath 方法創(chuàng)建目錄時會修改字符串的內容，因此需要復制一份字符串進行;

2、獲取 MMKV 對象

通過 mmkvWithID 方法可以獲取 MMKV 對象，它傳入的 mmapID 就對應了 SharedPreferences 中的 name，代表了一個文件對應的 name，而 relativePath 則對應了一個相對根目錄的相對路徑;

  1. @Nullable 
  2. public static MMKV mmkvWithID(String mmapID, String relativePath) { 
  3.     if (rootDir == null) { 
  4.         throw new IllegalStateException("You should Call MMKV.initialize() first."); 
  5.     } 
  6.     long handle = getMMKVWithID(mmapID, SINGLE_PROCESS_MODE, null, relativePath); 
  7.     if (handle == 0) { 
  8.         return null; 
  9.     } 
  10.     return new MMKV(handle); 
  11. } 

它調用到了 getMMKVWithId 這個 Native 方法，并獲取到了一個 handle 構造了 Java 層的 MMKV 對象返回;

Java 層通過持有 Native 層對象的地址從而與 Native 對象通信;

  1. extern "C" JNIEXPORT JNICALL jlong Java_com_tencent_mmkv_MMKV_getMMKVWithID( 
  2.     JNIEnv *env, jobject obj, jstring mmapID, jint mode, jstring cryptKey, jstring relativePath) { 
  3.     MMKV *kv = nullptr; 
  4.       // mmapID 為 null 返回空指針 
  5.     if (!mmapID) { 
  6.         return (jlong) kv; 
  7.     } 
  8.     string str = jstring2string(env, mmapID); 
  9.     bool done = false; 
  10.       // 如果需要進行加密，獲取用于加密的 key，最后調用 MMKV::mmkvWithID 
  11.     if (cryptKey) { 
  12.         string crypt = jstring2string(env, cryptKey); 
  13.         if (crypt.length() > 0) { 
  14.             if (relativePath) { 
  15.                 string path = jstring2string(env, relativePath); 
  16.                 kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, &crypt, &path); 
  17.             } else { 
  18.                 kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, &crypt, nullptr); 
  19.             } 
  20.             done = true; 
  21.         } 
  22.     } 
  23.       // 如果不需要加密，則調用 mmkvWithID 不傳入加密 key，表示不進行加密 
  24.     if (!done) { 
  25.         if (relativePath) { 
  26.             string path = jstring2string(env, relativePath); 
  27.             kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, nullptr, &path); 
  28.         } else { 
  29.             kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, nullptr, nullptr); 
  30.         } 
  31.     } 
  32.     return (jlong) kv; 
  33. } 

這里實際上調用了 MMKV::mmkvWithID 方法，它根據是否傳入用于加密的 key 以及是否使用相對路徑調用了不同的方法;

  1. MMKV *MMKV::mmkvWithID( 
  2.     const std::string &mmapID, int size, MMKVMode mode, string *cryptKey, string *relativePath) { 
  3.     if (mmapID.empty()) { 
  4.         return nullptr; 
  5.     } 
  6.       // 加鎖 
  7.     SCOPEDLOCK(g_instanceLock); 
  8.       // 將 mmapID 與 relativePath 結合生成 mmapKey 
  9.     auto mmapKey = mmapedKVKey(mmapID, relativePath); 
  10.       // 通過 mmapKey 在 map 中查找對應的 MMKV 對象并返回 
  11.     auto itr = g_instanceDic->find(mmapKey); 
  12.     if (itr != g_instanceDic->end()) { 
  13.         MMKV *kv = itr->second; 
  14.         return kv; 
  15.     } 
  16.       // 如果找不到，構建路徑后構建 MMKV 對象并加入 map 
  17.     if (relativePath) { 
  18.         auto filePath = mappedKVPathWithID(mmapID, mode, relativePath); 
  19.         if (!isFileExist(filePath)) { 
  20.             if (!createFile(filePath)) { 
  21.                 return nullptr; 
  22.             } 
  23.         } 
  24.         MMKVInfo("prepare to load %s (id %s) from relativePath %s", mmapID.c_str(), mmapKey.c_str(), 
  25.                  relativePath->c_str()); 
  26.     } 
  27.     auto kv = new MMKV(mmapID, size, mode, cryptKey, relativePath); 
  28.     (*g_instanceDic)[mmapKey] = kv; 
  29.     return kv; 
  30. } 

這里的步驟如下：

  • 通過 mmapedKVKey 方法對 mmapID 及 relativePath 進行結合生成了對應的 mmapKey，它會將它們兩者的結合經過 md5 從而生成對應的 key，主要目的是為了支持不同相對路徑下的同名 mmapID;
  • 通過 mmapKey 在 g_instanceDic 這個 map 中查找對應的 MMKV 對象，如果找到直接返回;
  • 如果找不到對應的 MMKV 對象，構建一個新的 MMKV 對象，加入 map 后返回;
  • 構造 MMKV 對象;

MMKV 的構造函數(shù)：

  1. MMKV::MMKV( 
  2.     const std::string &mmapID, int size, MMKVMode mode, string *cryptKey, string *relativePath) 
  3.     : m_mmapID(mmapedKVKey(mmapID, relativePath)) 
  4.     // ...) { 
  5.     // ... 
  6.     if (m_isAshmem) { 
  7.         m_ashmemFile = new MmapedFile(m_mmapID, static_cast<size_t>(size), MMAP_ASHMEM); 
  8.         m_fd = m_ashmemFile->getFd(); 
  9.     } else { 
  10.         m_ashmemFile = nullptr; 
  11.     } 
  12.         // 通過加密 key 構建 AES 加密對象 AESCrypt 
  13.     if (cryptKey && cryptKey->length() > 0) { 
  14.         m_crypter = new AESCrypt((const unsigned char *) cryptKey->data(), cryptKey->length()); 
  15.     } 
  16.         // 賦值操作 
  17.     // 加鎖后調用 loadFromFile 加載數(shù)據 
  18.     { 
  19.         SCOPEDLOCK(m_sharedProcessLock); 
  20.         loadFromFile(); 
  21.     } 
  22. } 
  • 進行了一些賦值操作，之后如果需要加密則根據用于加密的 cryptKey 生成對應的 AESCrypt 對象用于 AES 加密;
  • 加鎖后通過 loadFromFile 方法從文件中讀取數(shù)據，這里的鎖是一個跨進程的文件共享鎖;

3、從文件加載數(shù)據loadFromFile

我們都知道，MMKV 是基于 mmap 實現(xiàn)的，通過內存映射在高效率的同時保證了數(shù)據的同步寫入文件，loadFromFile 中就會真正進行內存映射：

  1. void MMKV::loadFromFile() { 
  2.     // ... 
  3.       // 打開對應的文件 
  4.     m_fd = open(m_path.c_str(), O_RDWR | O_CREAT, S_IRWXU); 
  5.     if (m_fd < 0) { 
  6.         MMKVError("fail to open:%s, %s", m_path.c_str(), strerror(errno)); 
  7.     } else { 
  8.           // 獲取文件大小 
  9.         m_size = 0; 
  10.         struct stat st = {0}; 
  11.         if (fstat(m_fd, &st) != -1) { 
  12.             m_size = static_cast<size_t>(st.st_size); 
  13.         } 
  14.         // 將文件大小對齊到頁大小的整數(shù)倍，用 0 填充不足的部分 
  15.         if (m_size < DEFAULT_MMAP_SIZE || (m_size % DEFAULT_MMAP_SIZE != 0)) { 
  16.             size_t oldSize = m_size; 
  17.             m_size = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE; 
  18.             if (ftruncate(m_fd, m_size) != 0) { 
  19.                 MMKVError("fail to truncate [%s] to size %zu, %s", m_mmapID.c_str(), m_size, 
  20.                           strerror(errno)); 
  21.                 m_size = static_cast<size_t>(st.st_size); 
  22.             } 
  23.             zeroFillFile(m_fd, oldSize, m_size - oldSize); 
  24.         } 
  25.           // 通過 mmap 將文件映射到內存 
  26.         m_ptr = (char *) mmap(nullptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0); 
  27.         if (m_ptr == MAP_FAILED) { 
  28.             MMKVError("fail to mmap [%s], %s", m_mmapID.c_str(), strerror(errno)); 
  29.         } else { 
  30.             memcpy(&m_actualSize, m_ptr, Fixed32Size); 
  31.             MMKVInfo("loading [%s] with %zu size in total, file size is %zu", m_mmapID.c_str(), 
  32.                      m_actualSize, m_size); 
  33.             bool loadFromFile = false, needFullWriteback = false; 
  34.             if (m_actualSize > 0) { 
  35.                 if (m_actualSize < m_size && m_actualSize + Fixed32Size <= m_size) { 
  36.                       // 對文件進行 CRC 校驗，如果失敗根據策略進行不同對處理 
  37.                     if (checkFileCRCValid()) { 
  38.                         loadFromFile = true; 
  39.                     } else { 
  40.                           // CRC 校驗失敗，如果策略是錯誤時恢復，則繼續(xù)讀取，并且最后需要進行回寫 
  41.                         auto strategic = onMMKVCRCCheckFail(m_mmapID); 
  42.                         if (strategic == OnErrorRecover) { 
  43.                             loadFromFile = true; 
  44.                             needFullWriteback = true; 
  45.                         } 
  46.                     } 
  47.                 } else { 
  48.                       // 文件大小有誤，若策略是錯誤時恢復，則繼續(xù)讀取，并且最后需要進行回寫 
  49.                     auto strategic = onMMKVFileLengthError(m_mmapID); 
  50.                     if (strategic == OnErrorRecover) { 
  51.                         loadFromFile = true; 
  52.                         needFullWriteback = true; 
  53.                     } 
  54.                 } 
  55.             } 
  56.               // 從文件中讀取內容 
  57.             if (loadFromFile) { 
  58.                 MMKVInfo("loading [%s] with crc %u sequence %u", m_mmapID.c_str(), 
  59.                          m_metaInfo.m_crcDigest, m_metaInfo.m_sequence); 
  60.                   // 讀取 MMBuffer 
  61.                 MMBuffer inputBuffer(m_ptr + Fixed32Size, m_actualSize, MMBufferNoCopy); 
  62.                 // 如果需要解密，對文件進行解密 
  63.                   if (m_crypter) { 
  64.                     decryptBuffer(*m_crypter, inputBuffer); 
  65.                 } 
  66.                   // 通過 MiniPBCoder 將 MMBuffer 轉換為 Map 
  67.                 m_dic.clear(); 
  68.                 MiniPBCoder::decodeMap(m_dic, inputBuffer); 
  69.                   // 構造用于輸出的 CodeOutputData 
  70.                 m_output = new CodedOutputData(m_ptr + Fixed32Size + m_actualSize, 
  71.                                                m_size - Fixed32Size - m_actualSize); 
  72.                 if (needFullWriteback) { 
  73.                     fullWriteback(); 
  74.                 } 
  75.             } else { 
  76.                 SCOPEDLOCK(m_exclusiveProcessLock); 
  77.                 if (m_actualSize > 0) { 
  78.                     writeAcutalSize(0); 
  79.                 } 
  80.                 m_output = new CodedOutputData(m_ptr + Fixed32Size, m_size - Fixed32Size); 
  81.                 recaculateCRCDigest(); 
  82.             } 
  83.             MMKVInfo("loaded [%s] with %zu values", m_mmapID.c_str(), m_dic.size()); 
  84.         } 
  85.     } 
  86.     if (!isFileValid()) { 
  87.         MMKVWarning("[%s] file not valid", m_mmapID.c_str()); 
  88.     } 
  89.     m_needLoadFromFile = false; 
  90. } 

步驟如下： 

  • 打開文件并獲取文件大小，將文件的大小對齊到頁的整數(shù)倍，不足則補 0(與內存映射的原理有關，內存映射是基于頁的換入換出機制實現(xiàn)的);
  • 通過 mmap 函數(shù)將文件映射到內存中，得到指向該區(qū)域的指針 m_ptr;
  • 對文件進行長度校驗及 CRC 校驗(循環(huán)冗余校驗，可以校驗文件完整性)，在失敗的情況下會根據當前策略進行抉擇，如果策略是失敗時恢復，則繼續(xù)讀取，并且在最后將 map 中的內容回寫到文件;
  • 通過 m_ptr 構造出一塊用于管理 MMKV 映射內存的 MMBuffer 對象，如果需要解密，通過之前構造的 AESCrypt 進行解密;
  • 由于 MMKV 使用了 protobuf 進行序列化，通過 MiniPBCoder::decodeMap 方法將 protobuf 轉換成對應的 map;
  • 構造用于輸出的 CodedOutputData 類，如果需要回寫(CRC 校驗或文件長度校驗失敗)，則調用 fullWriteback 方法將 map 中的數(shù)據回寫到文件;

4、數(shù)據寫入 

Java 層的 MMKV 對象繼承了 SharedPreferences 及 SharedPreferences.Editor 接口并實現(xiàn)了一系列如 putInt、putLong 的方法用于對存儲的數(shù)據進行修改;

  1. @Override 
  2. public Editor putInt(String key, int value) { 
  3.     encodeInt(nativeHandle, key, value); 
  4.     return this; 
  5. } 

它調用到了 encodeInt 這個 Native 方法： 

  1. extern "C" JNIEXPORT JNICALL jboolean Java_com_tencent_mmkv_MMKV_encodeInt( 
  2.     JNIEnv *env, jobject obj, jlong handle, jstring oKey, jint value) { 
  3.     MMKV *kv = reinterpret_cast<MMKV *>(handle); 
  4.     if (kv && oKey) { 
  5.         string key = jstring2string(env, oKey); 
  6.         return (jboolean) kv->setInt32(value, key); 
  7.     } 
  8.     return (jboolean) false; 
  9. } 

這里將 Java 層持有的 NativeHandle 轉為了對應的 MMKV 對象，之后調用了其 setInt32 方法：

  1. bool MMKV::setInt32(int32_t value, const std::string &key) { 
  2.     if (key.empty()) { 
  3.         return false; 
  4.     } 
  5.       // 構造值對應的 MMBuffer，通過 CodedOutputData 將其寫入 Buffer 
  6.     size_t size = pbInt32Size(value); 
  7.     MMBuffer data(size); 
  8.     CodedOutputData output(data.getPtr(), size); 
  9.     output.writeInt32(value); 
  10.     return setDataForKey(std::move(data), key); 
  11. } 
  • 獲取到了寫入的 value 在 protobuf 中所占據的大小，之后為其構造了對應的 MMBuffer 并將數(shù)據寫入了這段 Buffer，最后調用到了 setDataForKey 方法;
  • 同時可以發(fā)現(xiàn) CodedOutputData 是與 Buffer 交互的橋梁，可以通過它實現(xiàn)向 MMBuffer 中寫入數(shù)據;
  1. bool MMKV::setDataForKey(MMBuffer &&data, const std::string &key) { 
  2.     if (data.length() == 0 || key.empty()) { 
  3.         return false; 
  4.     } 
  5.       // 獲取寫鎖 
  6.     SCOPEDLOCK(m_lock); 
  7.     SCOPEDLOCK(m_exclusiveProcessLock); 
  8.       // 確保數(shù)據已讀入內存 
  9.     checkLoadData(); 
  10.     // 將 data 寫入 map 中 
  11.     auto itr = m_dic.find(key); 
  12.     if (itr == m_dic.end()) { 
  13.         itr = m_dic.emplace(key, std::move(data)).first; 
  14.     } else { 
  15.         itr->second = std::move(data); 
  16.     } 
  17.     m_hasFullWriteback = false; 
  18.     return appendDataWithKey(itr->second, key); 
  19. } 

數(shù)據已讀入內存的情況下將 data 寫入了對應的 map，之后調用了 appendDataWithKey 方法：

  1. bool MMKV::appendDataWithKey(const MMBuffer &data, const std::string &key) { 
  2.     size_t keyLength = key.length(); 
  3.       // 計算寫入到映射空間中的 size 
  4.     size_t size = keyLength + pbRawVarint32Size((int32_t) keyLength); 
  5.     size += data.length() + pbRawVarint32Size((int32_t) data.length()); 
  6.       // 要寫入，獲取寫鎖 
  7.     SCOPEDLOCK(m_exclusiveProcessLock); 
  8.       // 確定剩余映射空間足夠 
  9.     bool hasEnoughSize = ensureMemorySize(size); 
  10.     if (!hasEnoughSize || !isFileValid()) { 
  11.         return false; 
  12.     } 
  13.     if (m_actualSize == 0) { 
  14.         auto allData = MiniPBCoder::encodeDataWithObject(m_dic); 
  15.         if (allData.length() > 0) { 
  16.             if (m_crypter) { 
  17.                 m_crypter->reset(); 
  18.                 auto ptr = (unsigned char *) allData.getPtr(); 
  19.                 m_crypter->encrypt(ptr, ptr, allData.length()); 
  20.             } 
  21.             writeAcutalSize(allData.length()); 
  22.             m_output->writeRawData(allData); // note: don't write size of data 
  23.             recaculateCRCDigest(); 
  24.             return true; 
  25.         } 
  26.         return false; 
  27.     } else { 
  28.         writeAcutalSize(m_actualSize + size); 
  29.         m_output->writeString(key); 
  30.         m_output->writeData(data); // note: write size of data 
  31.         auto ptr = (uint8_t *) m_ptr + Fixed32Size + m_actualSize - size; 
  32.         if (m_crypter) { 
  33.             m_crypter->encrypt(ptr, ptr, size); 
  34.         } 
  35.         updateCRCDigest(ptr, size, KeepSequence); 
  36.         return true; 
  37.     } 
  38. } 
  • 首先計算了即將寫入到映射空間的內容大小，之后調用了 ensureMemorySize 方法確保剩余映射空間足夠;
  • 如果 m_actualSize 為 0，則會通過 MiniPBCoder::encodeDataWithObject 將整個 map 轉換為對應的 MMBuffer，加密后通過 CodedOutputData 寫入，最后重新計算 CRC 校驗碼。否則會將 key 和對應 data 寫入，最后更新 CRC 校驗碼;
  • m_actualSize 是位于文件的首部的，因此是否為 0 取決于文件對應位置;

注意的是：由于 protobuf 不支持增量更新，為了避免全量寫入帶來的性能問題，MMKV 在文件中的寫入并不是通過修改文件對應的位置，而是直接在后面 append 一條新的數(shù)據，即使是修改了已存在的 key。而讀取時只記錄最后一條對應 key 的數(shù)據，這樣顯然會在文件中存在冗余的數(shù)據。這樣設計的原因我認為是出于性能的考量，MMKV 中存在著一套內存重整機制用于對冗余的 key-value 數(shù)據進行處理。它正是在確保內存充足時實現(xiàn)的;

5、內存重整ensureMemorySize

我們接下來看看 ensureMemorySize 是如何確保映射空間是否足夠的：

  1. bool MMKV::ensureMemorySize(size_t newSize) { 
  2.     // ... 
  3.     if (newSize >= m_output->spaceLeft()) { 
  4.         // 如果內存剩余大小不足以寫入，嘗試進行內存重整，將 map 中的數(shù)據重新寫入 protobuf 文件 
  5.         static const int offset = pbFixed32Size(0); 
  6.         MMBuffer data = MiniPBCoder::encodeDataWithObject(m_dic); 
  7.         size_t lenNeeded = data.length() + offset + newSize; 
  8.         if (m_isAshmem) { 
  9.             if (lenNeeded > m_size) { 
  10.                 MMKVWarning("ashmem %s reach size limit:%zu, consider configure with larger size", 
  11.                             m_mmapID.c_str(), m_size); 
  12.                 return false; 
  13.             } 
  14.         } else { 
  15.             size_t avgItemSize = lenNeeded / std::max<size_t>(1, m_dic.size()); 
  16.             size_t futureUsage = avgItemSize * std::max<size_t>(8, (m_dic.size() + 1) / 2); 
  17.             // 如果內存重整后仍不足以寫入，則將大小不斷乘2直至足夠寫入，最后通過 mmap 重新映射文件 
  18.             if (lenNeeded >= m_size || (lenNeeded + futureUsage) >= m_size) { 
  19.                 size_t oldSize = m_size; 
  20.                 do { 
  21.                       // double 空間直至足夠 
  22.                     m_size *= 2; 
  23.                 } while (lenNeeded + futureUsage >= m_size); 
  24.                    // ... 
  25.                 if (ftruncate(m_fd, m_size) != 0) { 
  26.                     MMKVError("fail to truncate [%s] to size %zu, %s", m_mmapID.c_str(), m_size, 
  27.                               strerror(errno)); 
  28.                     m_size = oldSize; 
  29.                     return false; 
  30.                 } 
  31.                   // 用零填充不足部分 
  32.                 if (!zeroFillFile(m_fd, oldSize, m_size - oldSize)) { 
  33.                     MMKVError("fail to zeroFile [%s] to size %zu, %s", m_mmapID.c_str(), m_size, 
  34.                               strerror(errno)); 
  35.                     m_size = oldSize; 
  36.                     return false; 
  37.                 } 
  38.                                 // unmap 
  39.                 if (munmap(m_ptr, oldSize) != 0) { 
  40.                     MMKVError("fail to munmap [%s], %s", m_mmapID.c_str(), strerror(errno)); 
  41.                 } 
  42.                                 // 重新通過 mmap 映射 
  43.                 m_ptr = (char *) mmap(m_ptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0); 
  44.                 if (m_ptr == MAP_FAILED) { 
  45.                     MMKVError("fail to mmap [%s], %s", m_mmapID.c_str(), strerror(errno)); 
  46.                 } 
  47.                 // check if we fail to make more space 
  48.                 if (!isFileValid()) { 
  49.                     MMKVWarning("[%s] file not valid", m_mmapID.c_str()); 
  50.                     return false; 
  51.                 } 
  52.             } 
  53.         } 
  54.           // 加密數(shù)據 
  55.         if (m_crypter) { 
  56.             m_crypter->reset(); 
  57.             auto ptr = (unsigned char *) data.getPtr(); 
  58.             m_crypter->encrypt(ptr, ptr, data.length()); 
  59.         } 
  60.           // 重新構建并寫入數(shù)據 
  61.         writeAcutalSize(data.length()); 
  62.         delete m_output; 
  63.         m_output = new CodedOutputData(m_ptr + offset, m_size - offset); 
  64.         m_output->writeRawData(data); 
  65.         recaculateCRCDigest(); 
  66.         m_hasFullWriteback = true; 
  67.     } 
  68.     return true; 
  69. } 

內存重整步驟如下：

  • 當剩余映射空間不足以寫入需要寫入的內容，嘗試進行內存重整;
  • 內存重整會將文件清空，將 map 中的數(shù)據重新寫入文件，從而去除冗余數(shù)據;
  • 若內存重整后剩余映射空間仍然不足，不斷將映射空間 double 直到足夠，并用 mmap 重新映射;

6、刪除remove

通過 Java 層 MMKV 的 remove 方法可以實現(xiàn)刪除操作：

  1. @Override 
  2. public Editor remove(String key) { 
  3.     removeValueForKey(key); 
  4.     return this; 
  5. } 

它調用了 removeValueForKey 這個 Native 方法：

  1. extern "C" JNIEXPORT JNICALL void Java_com_tencent_mmkv_MMKV_removeValueForKey(JNIEnv *env, 
  2.                                                                                jobject instance, 
  3.                                                                                jlong handle, 
  4.                                                                                jstring oKey) { 
  5.     MMKV *kv = reinterpret_cast<MMKV *>(handle); 
  6.     if (kv && oKey) { 
  7.         string key = jstring2string(env, oKey); 
  8.         kv->removeValueForKey(key); 
  9.     } 
  10. } 

這里調用了 Native 層 MMKV 的 removeValueForKey 方法：

  1. void MMKV::removeValueForKey(const std::string &key) { 
  2.     if (key.empty()) { 
  3.         return; 
  4.     } 
  5.     SCOPEDLOCK(m_lock); 
  6.     SCOPEDLOCK(m_exclusiveProcessLock); 
  7.     checkLoadData(); 
  8.     removeDataForKey(key); 
  9. } 

它在數(shù)據讀入內存的前提下，調用了 removeDataForKey 方法：

  1. bool MMKV::removeDataForKey(const std::string &key) { 
  2.     if (key.empty()) { 
  3.         return false; 
  4.     } 
  5.     auto deleteCount = m_dic.erase(key); 
  6.     if (deleteCount > 0) { 
  7.         m_hasFullWriteback = false; 
  8.         static MMBuffer nan(0); 
  9.         return appendDataWithKey(nan, key); 
  10.     } 
  11.     return false; 
  12. } 
  • 這里實際上是構造了一條 size 為 0 的 MMBuffer 并調用 appendDataWithKey 將其 append 到 protobuf 文件中，并將 key 對應的內容從 map 中刪除;
  • 讀取時發(fā)現(xiàn)它的 size 為 0，則會認為這條數(shù)據已經刪除;

7、讀取

我們通過 getInt、getLong 等操作可以實現(xiàn)對數(shù)據的讀取，我們以 getInt 為例：

  1. @Override 
  2. public int getInt(String key, int defValue) { 
  3.     return decodeInt(nativeHandle, key, defValue); 
  4. } 

它調用到了 decodeInt 這個 Native 方法：

  1. extern "C" JNIEXPORT JNICALL jint Java_com_tencent_mmkv_MMKV_decodeInt( 
  2.     JNIEnv *env, jobject obj, jlong handle, jstring oKey, jint defaultValue) { 
  3.     MMKV *kv = reinterpret_cast<MMKV *>(handle); 
  4.     if (kv && oKey) { 
  5.         string key = jstring2string(env, oKey); 
  6.         return (jint) kv->getInt32ForKey(key, defaultValue); 
  7.     } 
  8.     return defaultValue; 
  9. } 

它調用到了 MMKV.getInt32ForKey 方法：

  1. int32_t MMKV::getInt32ForKey(const std::string &key, int32_t defaultValue) { 
  2.     if (key.empty()) { 
  3.         return defaultValue; 
  4.     } 
  5.     SCOPEDLOCK(m_lock); 
  6.     auto &data = getDataForKey(key); 
  7.     if (data.length() > 0) { 
  8.         CodedInputData input(data.getPtr(), data.length()); 
  9.         return input.readInt32(); 
  10.     } 
  11.     return defaultValue; 
  12. } 

調用了 getDataForKey 方法獲取到了 key 對應的 MMBuffer，之后通過 CodedInputData 將數(shù)據讀出并返回;

長度為 0 時會將其視為不存在，返回默認值;

  1. const MMBuffer &MMKV::getDataForKey(const std::string &key) { 
  2.     checkLoadData(); 
  3.     auto itr = m_dic.find(key); 
  4.     if (itr != m_dic.end()) { 
  5.         return itr->second; 
  6.     } 
  7.     static MMBuffer nan(0); 
  8.     return nan; 
  9. } 

這里實際上是通過在 Map 中尋找從而實現(xiàn)，找不到會返回 size 為 0 的 Buffer;

MMKV讀寫是直接讀寫到mmap文件映射的內存上，繞開了普通讀寫io需要進入內核，寫到磁盤的過程;

總結

MMKV使用的注意事項

1.保證每一個文件存儲的數(shù)據都比較小，也就說需要把數(shù)據根據業(yè)務線存儲分散。這要就不會把虛擬內存消耗過快;

2.適當?shù)臅r候釋放一部分內存數(shù)據，比如在App中監(jiān)聽onTrimMemory方法，在Java內存吃緊的情況下進行MMKV的trim操作; 

3.不需要使用的時候，最好把MMKV給close掉,甚至調用exit方法。

 

責任編輯：武曉燕 來源： Android開發(fā)編程
開源輕量級緩存
相關推薦

2022-02-12 21:05:11

異步爬蟲框架

2016-09-22 15:50:38

JavascriptRedux源碼解析

2019-09-18 18:12:35

騰訊開源物聯(lián)網

2021-09-09 06:55:43

AndroidViewDragHel原理

2021-09-01 06:48:16

AndroidGlide緩存

2019-03-10 20:55:11

瀏覽器Midori開源

2022-06-01 09:28:43

??Umami??開源

2021-07-03 08:51:30

源碼Netty選擇器

2021-05-17 09:50:06

Kubebuilde源碼CURD

2019-05-07 14:42:03

深度學習編程人工智能

2021-09-02 07:00:01

Glide流程Android

2013-02-20 14:54:03

C#.NETNDatabase

2022-08-11 08:35:40

Hanko開源

2025-02-19 09:55:39

2022-05-20 10:32:49

事件循環(huán)器事件隊列鴻蒙

2009-07-14 18:05:28

輕量級Swing組件

2009-07-17 14:38:51

輕量級Swing組件

2015-09-16 09:10:27

Java源碼解析

2010-01-06 14:19:47

JSON輕量級

2022-05-16 07:37:58

SQL 編輯器數(shù)據庫管理工具
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 国产成人jvid在线播放 | 99热.com | 亚洲在线一区二区 | 久久久久久久电影 | 欧美一级二级三级 | 一级片视频免费观看 | 久久久久久久久久爱 | 国产乱码精品1区2区3区 | 亚洲欧洲在线看 | 日韩a在线 | 国产免费一区二区三区最新6 | 狠狠操在线| 亚洲 中文 欧美 日韩 在线观看 | 亚洲精品一区二区三区蜜桃久 | 欧美中文字幕一区 | 国产日韩欧美在线播放 | 日韩一区二区三区视频 | 欧美日韩国产在线观看 | 在线观看电影av | 国产精品欧美一区二区三区不卡 | 日韩午夜网站 | 特级黄一级播放 | 日日摸日日添日日躁av | 四虎成人在线播放 | 亚洲 中文 欧美 日韩 在线观看 | 成av在线| 精品99在线 | 中日字幕大片在线播放 | 国产精品视频不卡 | 999精品视频 | 欧美激情一区二区 | 国产传媒视频在线观看 | 99精品视频在线 | 中文字幕 在线观看 | 视频一二三区 | 久久精品一 | 日韩一级黄色片 | 日韩成人在线电影 | 香蕉婷婷 | 天天操妹子 | 欧美爱爱视频网站 |