mmkv框架源码浅析(下)

由于篇幅过长,就分成三篇来分析mmkv这块内容,虽然代码量不多,但集成了一些基础知识,掌握基本知识,学其他的会更快些。

八) 使用文件锁来调度多进程通过共享内存协作

mmkv下面有一些源文件,其中ScopedLock.hpp通过ARII手段来通过构造时lock,离开函数作用域后析构unlock,当然实现中,拷贝构造和赋值函数都用delete修饰;

native-bridge.cpp应该是C++和java之间的通道,在java层面调用C++的逻辑;

ThreadLock.h/ThreadLock.cpp是个封装pthread_mutex_t的锁,其中在初始化锁时有个属性PTHREAD_MUTEX_RECURSIVE,表示可递归;

PBUtility.h/PBUtility.cpp如其名,是一些基本的接口类,有些是c++11的知识点,比如constexpr可用于在编译期就计算出来的表达式;类型转换如leveldb中的Varint类型:

 23 uint32_t pbRawVarint32Size(int32_t value) {
 24     if ((value & (0xffffffff << 7)) == 0) {
 25         return 1;
 26     } else if ((value & (0xffffffff << 14)) == 0) {
 27         return 2;
 28     } else if ((value & (0xffffffff << 21)) == 0) {
 29         return 3;
 30     } else if ((value & (0xffffffff << 28)) == 0) {
 31         return 4;
 32     }
 33     return 5;
 34 }

上面实现算出一个int32_t用Varint类型来表示,占用多少字节,每个字节的最高位不存储数据,表示是否还有后续内容;

MMBuffer.h/MMBuffer.cpp封装了void *ptrsize_t size的缓冲区,和leveldb中的slice有点区别,区别是否是对源地址内容重新拷贝一份而不简单的指向同一个地址,但与redis中的sds有点类似,不过后者是二进制安全的,分配空间策略也与vector类似;MMBuffer.cpp中也有移动拷贝和赋值相关的接口;

InterProcessLock.h/InterProcessLock.cpp 改造了文件锁,加了类型和读写引用计数,实现原理参考之前的内容;
MMKVLog.h是日志相关的接口实现;
aes目录下有不同的加解密实现;

MMKVMetaInfo.hpp是用于存放在共享内存中的元数据:

 28 struct MMKVMetaInfo {
 29     uint32_t m_crcDigest = 0;
 30     uint32_t m_version = 1;  //版本号
 31     uint32_t m_sequence = 0; // full write-back count
 32     //more code...
 42 };

这个结构是在多进程同步数据的时候,用于检查内存地址,大小是否发生改变,具体使用和实现在下面说明;

MmapedFile.h/MmapedFile.cpp封装了共享内存映mmap和munmap相关的实现;这里有映射文件和/dev/shm,分析的时候会以文件为例,因为有些注意点在里面,可以参考这里认真分析mmap:是什么 为什么 怎么用

 40 class MmapedFile {
 41     std::string m_name;
 42     int m_fd;
 43     void *m_segmentPtr;
 44     size_t m_segmentSize;
 66 };

 36 MmapedFile::MmapedFile(const std::string &path, size_t size, bool fileType)
 37     : m_name(path), m_fd(-1), m_segmentPtr(nullptr),m_segmentSize(0), m_fileType(fileType) {
 38     if (m_fileType == MMAP_FILE) {
 39         m_fd = open(m_name.c_str(), O_RDWR | O_CREAT, S_IRWXU);
 40         if (m_fd < 0) {
 42         } else {
 43             struct stat st = {};
 44             if (fstat(m_fd, &st) != -1) {
 45                 m_segmentSize = static_cast(st.st_size);
 46             }
 47             if (m_segmentSize < DEFAULT_MMAP_SIZE) {
 48                 m_segmentSize = static_cast(DEFAULT_MMAP_SIZE);
 49                 if (ftruncate(m_fd, m_segmentSize) != 0 || !zeroFillFile(m_fd, 0, m_segmentSize)) {
 51                               m_segmentSize, strerror(errno));
 52                     close(m_fd);
 53                     m_fd = -1;
 54                     removeFile(m_name);
 55                     return;
 56                 }
 57             }
 58             m_segmentPtr =
 59                 (char *) mmap(nullptr, m_segmentSize, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
 60             if (m_segmentPtr == MAP_FAILED) {
 62                 close(m_fd);
 63                 m_fd = -1;
 64                 m_segmentPtr = nullptr;
 65             }
 66         }
 67     } else {
 68         m_fd = open(ASHMEM_NAME_DEF, O_RDWR);
            //more code...
 91     }
 92 }

121 MmapedFile::~MmapedFile() {
122     if (m_segmentPtr != MAP_FAILED && m_segmentPtr != nullptr) {
123         munmap(m_segmentPtr, m_segmentSize);
124         m_segmentPtr = nullptr;
125     }
126     if (m_fd >= 0) {
127         close(m_fd);
128         m_fd = -1;
129     }
130 }

引用“mmap映射区域大小必须是物理页大小(page_size)的整倍数(32位系统中通常是4k字节)。原因是,内存的最小粒度是页,而进程虚拟地址空间和内存的映射也是以页为单位。为了匹配内存的操作,mmap从磁盘到虚拟地址空间的映射也必须是页。”

CodedInputData.h/CodedInputData.cpp封装了数据的读,可以有一定的格式:

 28 class CodedInputData {
 29     uint8_t *m_ptr;
 30     int32_t m_size;
 31     int32_t m_position;
 63 };

 28 CodedInputData::CodedInputData(const void *oData, int32_t length)
 29     : m_ptr((uint8_t *) oData), m_size(length), m_position(0) {
 30     assert(m_ptr); //其实从oData中读数据
 31 }

 87 MMBuffer CodedInputData::readData() {
 88     int32_t size = this->readRawVarint32();
 89     if (size < 0) {
 91         return MMBuffer(0);
 92     }
 93 
 94     if (size <= m_size - m_position) {
 95         MMBuffer data(((int8_t *) m_ptr) + m_position, size);
 96         m_position += size;
 97         return data;
 98     } else {
100         return MMBuffer(0);
101     }
102 }

162 int8_t CodedInputData::readRawByte() {
163     if (m_position == m_size) {
165         return 0;
166     }
167     int8_t *bytes = (int8_t *) m_ptr;
168     return bytes[m_position++];
169 }

CodedOutputData.h/CodedOutputData.cpp是封装了写数据:

 28 class CodedOutputData {
 29     uint8_t *m_ptr;
 30     size_t m_size;
 31     int32_t m_position;
 67 };

 27 CodedOutputData::CodedOutputData(void *ptr, size_t len)
 28     : m_ptr((uint8_t *) ptr), m_size(len), m_position(0) {
 29     assert(m_ptr); //写入ptr
 30 }
124 void CodedOutputData::writeRawLittleEndian32(int32_t value) {
125     this->writeRawByte(static_cast((value) &0xff));
126     this->writeRawByte(static_cast((value >> 8) & 0xff));
127     this->writeRawByte(static_cast((value >> 16) & 0xff));
128     this->writeRawByte(static_cast((value >> 24) & 0xff));
129 }  //把一个int32_t以小端格式写进m_ptr中

100 void CodedOutputData::writeRawVarint32(int32_t value) {
101     while (true) {
102         if ((value & ~0x7f) == 0) {
103             this->writeRawByte(static_cast(value));
104             return;
105         } else {
106             this->writeRawByte(static_cast((value & 0x7F) | 0x80)); //先取七位并或上第八位,表示后面还有数据
107             value = logicalRightShift32(value, 7); //右移掉低七位
108         }
109     }
110 }  //以Varint格式写
 85 void CodedOutputData::writeRawByte(uint8_t value) {
 86     if (m_position == m_size) {
 88         return;
 89     }
 90 
 91     m_ptr[m_position++] = value;
 92 }

以上输入输出的实现还是比较好理解;但是需要注意在把int32_t有符号的类型转换成Varint类型时,移位可能补上符号位,这里需要特别处理下,相关的有无符号转换表示等基础知识可以参考下《深入理解计算机系统第二章节》:

 69 static inline uint32_t Int32ToUInt32(int32_t v) {
 70     Converter converter;
 71     converter.first = v;
 72     return converter.second;
 73 }

 26 template 
 27 union Converter {
 28     static_assert(sizeof(T) == sizeof(P), "size not match");
 29     T first;
 30     P second;
 31 };

MiniPBCoder.h/MiniPBCoder.cpp用于Encode/decode处理,举例对string进行Encode/decode:

232 string MiniPBCoder::decodeOneString() {
233     return m_inputData->readString();
234 }
235 
273 string MiniPBCoder::decodeString(const MMBuffer &oData) {
274     MiniPBCoder oCoder(&oData);
275     return oCoder.decodeOneString();
276 }
174 MMBuffer MiniPBCoder::getEncodeData(const string &str) {
175     m_encodeItems = new vector();
176     size_t index = prepareObjectForEncode(str);
177     PBEncodeItem *oItem = (index < m_encodeItems->size()) ? &(*m_encodeItems)[index] : nullptr;
178     if (oItem && oItem->compiledSize > 0) {
179         m_outputBuffer = new MMBuffer(oItem->compiledSize);
180         m_outputData = new CodedOutputData(m_outputBuffer->getPtr(), m_outputBuffer->length());
181 
182         writeRootObject();
183     }
184 
185     return move(*m_outputBuffer);
186 }

 90 size_t MiniPBCoder::prepareObjectForEncode(const string &str) {
 91     m_encodeItems->push_back(PBEncodeItem());
 92     PBEncodeItem *encodeItem = &(m_encodeItems->back());
 93     size_t index = m_encodeItems->size() - 1;
 94     {
 95         encodeItem->type = PBEncodeItemType_String;
 96         encodeItem->value.strValue = &str;
 97         encodeItem->valueSize = static_cast(str.size());
 98     }
 99     encodeItem->compiledSize = pbRawVarint32Size(encodeItem->valueSize) + encodeItem->valueSize; //数据大小占用字节数加内存本身占用的内存
100 
101     return index;
102 }

 66 void MiniPBCoder::writeRootObject() {
 67     for (size_t index = 0, total = m_encodeItems->size(); index < total; index++) {
 68         PBEncodeItem *encodeItem = &(*m_encodeItems)[index];
 69         switch (encodeItem->type) {
 70             case PBEncodeItemType_String: {
 71                 m_outputData->writeString(*(encodeItem->value.strValue));
 72                 break;  //依次把string item 写进m_outputData
 73             }
 74             case PBEncodeItemType_Data: {
 75                 m_outputData->writeData(*(encodeItem->value.bufferValue));
 76                 break;
 77             }
 78             case PBEncodeItemType_Container: {
 79                 m_outputData->writeRawVarint32(encodeItem->valueSize);
 80                 break;
 81             }
 82             case PBEncodeItemType_None: {
 84                 break;
 85             }
 86         }
 87     }
 88 }

以上所介绍的都是基本的,主要的逻辑在MMKV.h/MMKV.cpp中,剩下的部分会分析重点部分,然后以一个读和写操作来分析工作流程,其他的跳过。
以下是类的声明,数据成员如下:

 44 class MMKV {
 45     std::unordered_map m_dic;
 46     std::string m_mmapID;  //共享内存id
 47     std::string m_path; //文件名,以它来举例
 48     std::string m_crcPath;
 49     int m_fd;
 50     char *m_ptr;
 51     size_t m_size;
 52     size_t m_actualSize;
 53     CodedOutputData *m_output;
 54     MmapedFile *m_ashmemFile;
 55 
 56     bool m_needLoadFromFile;
 57 
 58     uint32_t m_crcDigest;
 59     MmapedFile m_metaFile;
 60     MMKVMetaInfo m_metaInfo;
 61 
 62     AESCrypt *m_crypter; //加解密相关
 63 
 64     ThreadLock m_lock;  //支持递归加锁
 65     FileLock m_fileLock;  //用于初始化读写锁的文件锁
 66     InterProcessLock m_sharedProcessLock; //读锁
 67     InterProcessLock m_exclusiveProcessLock; //写锁
 217 };

构造:

  59 MMKV::MMKV(const std::string &mmapID, int size, MMKVMode mode, string *cryptKey)
  60     : m_mmapID(mmapID)
  61     , m_path(mappedKVPathWithID(m_mmapID, mode))
  62     , m_crcPath(crcPathWithID(m_mmapID, mode))
  63     , m_metaFile(m_crcPath, DEFAULT_MMAP_SIZE, (mode & MMKV_ASHMEM) ? MMAP_ASHMEM : MMAP_FILE)
  64     , m_crypter(nullptr)
  65     , m_fileLock(m_metaFile.getFd())
  66     , m_sharedProcessLock(&m_fileLock, SharedLockType)
  67     , m_exclusiveProcessLock(&m_fileLock, ExclusiveLockType)
  68     , m_isInterProcess((mode & MMKV_MULTI_PROCESS) != 0) //是否是多进程的
  69     , m_isAshmem((mode & MMKV_ASHMEM) != 0) {
  70     m_fd = -1;
  71     m_ptr = nullptr;
  72     m_size = 0;
  73     m_actualSize = 0;
  74     m_output = nullptr;
  75    
  76     if (m_isAshmem) {
  79     } else {
  80         m_ashmemFile = nullptr;
  81     }
  82                    
  87     m_needLoadFromFile = true;
  88 
  89     m_crcDigest = 0;
  90 
  91     m_sharedProcessLock.m_enable = m_isInterProcess;//文件锁是否用于多进程,这样加解锁是否要真正进行
  92     m_exclusiveProcessLock.m_enable = m_isInterProcess;//同上  93 
  94     // sensitive zone
  95     {
  96         SCOPEDLOCK(m_sharedProcessLock); //加读锁
  97         loadFromFile(); //加载数据
  98     }
  99 }

简化起见,不考虑从/dev/shm中映射,不考虑cryptKey相关的逻辑,把里面的相关代码给省略,对m_metaFile区域初始化文件锁,因为在共享内存中,可能有多个进程操作。

加载数据:

 267 void MMKV::loadFromFile() {
 268     if (m_isAshmem) {
 270         return;
 271     }
 273     m_metaInfo.read(m_metaFile.getMemory()); //从共享内存中读元数据
 274 
 275     m_fd = open(m_path.c_str(), O_RDWR | O_CREAT, S_IRWXU);
 278     } else {   
 279         m_size = 0;
 280         struct stat st = {0};
 281         if (fstat(m_fd, &st) != -1) {
 282             m_size = static_cast(st.st_size);
 283         }      
 284         // round up to (n * pagesize)
 285         if (m_size < DEFAULT_MMAP_SIZE || (m_size % DEFAULT_MMAP_SIZE != 0)) {
 286             size_t oldSize = m_size;
 287             m_size = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
 288             if (ftruncate(m_fd, m_size) != 0) { 
 291                 m_size = static_cast(st.st_size);
 292             }
 293             zeroFillFile(m_fd, oldSize, m_size - oldSize); 
 294         }
 295         m_ptr = (char *) mmap(nullptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0); //以MAP_SHARED进行映射
 296         if (m_ptr == MAP_FAILED) {
 298         } else {
 299             memcpy(&m_actualSize, m_ptr, Fixed32Size);
 302             bool loaded = false;
 303             if (m_actualSize > 0) {
 304                 if (m_actualSize < m_size && m_actualSize + Fixed32Size <= m_size) {
 305                     if (checkFileCRCValid()) {
 308                         MMBuffer inputBuffer(m_ptr + Fixed32Size, m_actualSize, MMBufferNoCopy);
 309                         if (m_crypter) {
 310                             decryptBuffer(*m_crypter, inputBuffer);
 311                         }
 312                         m_dic = MiniPBCoder::decodeMap(inputBuffer);
 313                         m_output = new CodedOutputData(m_ptr + Fixed32Size + m_actualSize,
 314                                                        m_size - Fixed32Size - m_actualSize);
 315                         loaded = true;
 316                     }
 317                 }
 318             }

代码行273主要是从共享内存中读元数据,里面含有字段信息:m_crcDigest/m_version/m_sequence,具体作用在后面说。
279到295开始映射,并根据页大小来,然后从oldSize开始初始化m_size - oldSize个字节内容为0。当然一开始没有文件的时候,初始化一页都为0的内容,然后进行映射,此时进行读写m_ptr时就相当于读写文件。
一开始文件中啥都没有,所以不会执行303〜315逻辑:

 319             if (!loaded) {
 320                 SCOPEDLOCK(m_exclusiveProcessLock);
 321 
 322                 if (m_actualSize > 0) {
 323                     writeAcutalSize(0);
 324                 }
 325                 m_output = new CodedOutputData(m_ptr + Fixed32Size, m_size - Fixed32Size);
 326                 recaculateCRCDigest();
 327             }

然后设置m_ptr开始的Fixed32Size个字节偏移量处开始写,然后重新计算签名recaculateCRCDigest,然后写入到共享内存处,这样当其他进入进行写的时候,可能会做些额外处理:

 890 void MMKV::updateCRCDigest(const uint8_t *ptr, size_t length, bool increaseSequence) {
 891     if (!ptr) {
 892         return;
 893     }
 894     m_crcDigest = (uint32_t) crc32(m_crcDigest, ptr, (uint32_t) length);
 895 
 896     void *crcPtr = m_metaFile.getMemory();
 897     if (crcPtr == nullptr || crcPtr == MAP_FAILED) {
 898         return;
 899     }
 900 
 901     m_metaInfo.m_crcDigest = m_crcDigest;
 902     if (increaseSequence) {
 903         m_metaInfo.m_sequence++;
 904     }
 905     if (m_metaInfo.m_version == 0) {
 906         m_metaInfo.m_version = 1;
 907     }
 908     m_metaInfo.write(crcPtr);
 909 }

当有文件内容时,先进行校验,通过的话则从文件中建立m_dic表并设置输出:

 303             if (m_actualSize > 0) {
 304                 if (m_actualSize < m_size && m_actualSize + Fixed32Size <= m_size) {
 305                     if (checkFileCRCValid()) { //校验
 308                         MMBuffer inputBuffer(m_ptr + Fixed32Size, m_actualSize, MMBufferNoCopy) ; //读文件内容
 309                         if (m_crypter) { //是否加密
 310                             decryptBuffer(*m_crypter, inputBuffer);
 311                         }
 312                         m_dic = MiniPBCoder::decodeMap(inputBuffer);//decode文件中的内容
 313                         m_output = new CodedOutputData(m_ptr + Fixed32Size + m_actualSize,
 314                                                        m_size - Fixed32Size - m_actualSize); //设置输出
 315                         loaded = true;
 316                     }
 317                 }
 318             }

 867 bool MMKV::checkFileCRCValid() {
 868     if (m_ptr && m_ptr != MAP_FAILED) {
 869         constexpr int offset = pbFixed32Size(0);
 870         m_crcDigest =
 871             (uint32_t) crc32(0, (const uint8_t *) m_ptr + offset, (uint32_t) m_actualSize);
 872         m_metaInfo.read(m_metaFile.getMemory());
 873         if (m_crcDigest == m_metaInfo.m_crcDigest) {
 874             return true;
 875         }//从元数据中读出来的值跟文件内容计算值一遍比较
 878     }
 879     return false;
 880 }

以上是加载的过程,从代码实现上看,文件中内容格式是:大小+内容,但是大小只占头4个字节。

以读一个string为例来说明读的过程:

 997 bool MMKV::getStringForKey(const std::string &key, std::string &result) {
 998     if (key.empty()) {
 999         return false;
1000     }
1001     auto &data = getDataForKey(key);
1002     if (data.length() > 0) {
1003         result = MiniPBCoder::decodeString(data); //decode内容
1004         return true;
1005     }
1006     return false;
1007 }

 644 const MMBuffer &MMKV::getDataForKey(const std::string &key) {
 645     SCOPEDLOCK(m_lock);
 646     checkLoadData();  //检查是否要重新load
 647     auto itr = m_dic.find(key);
 648     if (itr != m_dic.end()) {
 649         return itr->second;
 650     }
 651     static MMBuffer nan(0); //没找到,返回个特殊的
 652     return nan;
 653 }

下面这部分算是mmkv的核心设计了,当从文件中加载后m_needLoadFromFilefalse,即不需要在每次查询时是否重新load,但对于多进程来说,可能在load后其他进程更新了内容,所以可能需要重新load:

 437 void MMKV::checkLoadData() {
 438     if (m_needLoadFromFile) {
 439         SCOPEDLOCK(m_sharedProcessLock);
 440 
 441         m_needLoadFromFile = false;
 442         loadFromFile();  //从文件加载,并重置状态
 443         return;
 444     }
 445     if (!m_isInterProcess) {
 446         return;  //单进程直接返回
 447     }
 448 
 449     // TODO: atomic lock m_metaFile?
 450     MMKVMetaInfo metaInfo;
 451     metaInfo.read(m_metaFile.getMemory());
 452     if (m_metaInfo.m_sequence != metaInfo.m_sequence) {
 455         SCOPEDLOCK(m_sharedProcessLock);
 456 
 457         clearMemoryState(); //重置相关数据结构
 458         loadFromFile(); //重新从文件中mmap
 459     } else if (m_metaInfo.m_crcDigest != metaInfo.m_crcDigest) {
 462         SCOPEDLOCK(m_sharedProcessLock);
 463 
 464         size_t fileSize = 0;
 465         if (m_isAshmem) {
 466             fileSize = m_size;
 467         } else {
 468             struct stat st = {0};
 469             if (fstat(m_fd, &st) != -1) {
 470                 fileSize = (size_t) st.st_size;
 471             }
 472         }
 473         if (m_size != fileSize) {
 476             clearMemoryState();
 477             loadFromFile();
 478         } else {
 479             partialLoadFromFile();
 480         }
 481     }
 482 }

代码450〜458,从共享内存中读最新的元数据,然后比较序列号,不相等则内存进行了重整。
如果校验码不一致,则内容发生变化,这里检查[文件]是否大小不同,如果不同则重新加载,如果不是则部分加载,因为此时共内存内存中的数据可能还没有msync到文件中去,只是侧面反映共享内存中的数据增加了:

 389 void MMKV::partialLoadFromFile() {
 390     m_metaInfo.read(m_metaFile.getMemory()); //获取最新的元数据
 391 
 392     size_t oldActualSize = m_actualSize;
 393     memcpy(&m_actualSize, m_ptr, Fixed32Size);
 397     if (m_actualSize > 0) {
 398         if (m_actualSize < m_size && m_actualSize + Fixed32Size <= m_size) {
 399             if (m_actualSize > oldActualSize) {
 400                 size_t bufferSize = m_actualSize - oldActualSize; //部分加载
 401                 MMBuffer inputBuffer(m_ptr + Fixed32Size + oldActualSize, bufferSize,
 402                                      MMBufferNoCopy);
 403                 // incremental update crc digest
 404                 m_crcDigest = (uint32_t) crc32(m_crcDigest, (const uint8_t *) inputBuffer.getPtr(),
 405                                                static_cast(inputBuffer.length()));
 406                 if (m_crcDigest == m_metaInfo.m_crcDigest) {
 407                     if (m_crypter) {
 408                         decryptBuffer(*m_crypter, inputBuffer);
 409                     }
 410                     auto dic = MiniPBCoder::decodeMap(inputBuffer, bufferSize);
 411                     for (auto &itr : dic) {
 412                         //m_dic[itr.first] = std::move(itr.second);
 413                         auto target = m_dic.find(itr.first);
 414                         if (target == m_dic.end()) {
 415                             m_dic.emplace(itr.first, std::move(itr.second));
 416                         } else {
 417                             target->second = std::move(itr.second);
 418                         }
 419                     } //调整m_dic
 420                     m_output->seek(bufferSize);
 424                     return;
 425                 } else {
 428                 }
 429             }
 430         }
 431     }
 432     //到这里,说明上面部分load出错,进行清理状态并重新mmap
 433     clearMemoryState();
 434     loadFromFile();
 435 }

写及内存变化:

 913 bool MMKV::setStringForKey(const std::string &value, const std::string &key) {
 914     if (key.empty()) {
 915         return false;
 916     }
 917     auto data = MiniPBCoder::encodeDataWithObject(value);
 918     return setDataForKey(std::move(data), key);
 919 }

 655 bool MMKV::setDataForKey(MMBuffer &&data, const std::string &key) {
 656     if (data.length() == 0 || key.empty()) {
 657         return false;
 658     }
 659     SCOPEDLOCK(m_lock);
 660     SCOPEDLOCK(m_exclusiveProcessLock);
 661     checkLoadData();
 662 
 663     // m_dic[key] = std::move(data);
 664     auto itr = m_dic.find(key);
 665     if (itr == m_dic.end()) {
 666         itr = m_dic.emplace(key, std::move(data)).first;
 667     } else {
 668         itr->second = std::move(data);
 669     }
 670 
 671     return appendDataWithKey(itr->second, key);
 672 }

 688 bool MMKV::appendDataWithKey(const MMBuffer &data, const std::string &key) {
 689     size_t keyLength = key.length();
 690     // size needed to encode the key
 691     size_t size = keyLength + pbRawVarint32Size((int32_t) keyLength);
 692     // size needed to encode the value
 693     size += data.length() + pbRawVarint32Size((int32_t) data.length());
 694 
 695     SCOPEDLOCK(m_exclusiveProcessLock);//加写锁
 696 
 697     bool hasEnoughSize = ensureMemorySize(size);//检查是否有足够的空间
 698 
 699     if (!hasEnoughSize || !isFileValid()) {
 700         return false;
 701     }
 702     if (m_actualSize == 0) {
 703         auto allData = MiniPBCoder::encodeDataWithObject(m_dic);
 704         if (allData.length() > 0) {
 705             if (m_crypter) {
 706                 m_crypter->reset();
 707                 auto ptr = (unsigned char *) allData.getPtr();
 708                 m_crypter->encrypt(ptr, ptr, allData.length());
 709             }
 710             writeAcutalSize(allData.length());
 711             m_output->writeRawData(allData); // note: don't write size of data
 712             recaculateCRCDigest();
 713             return true;
 714         }
 715         return false;
 716     } else {
 717         writeAcutalSize(m_actualSize + size); //更新文件大小
 718         m_output->writeString(key);
 719         m_output->writeData(data); // note: write size of data
 720 
 721         auto ptr = (uint8_t *) m_ptr + Fixed32Size + m_actualSize - size;
 722         if (m_crypter) {
 723             m_crypter->encrypt(ptr, ptr, size);
 724         }
 725         updateCRCDigest(ptr, size, KeepSequence); //更新元数据的校验码
 726 
 727         return true;
 728     }
 729 }

 636 void MMKV::writeAcutalSize(size_t actualSize) {
 640     memcpy(m_ptr, &actualSize, Fixed32Size); //更新文件大小
 641     m_actualSize = actualSize;
 642 }

先检查是否有足够的空间ensureMemorySize

 560 bool MMKV::ensureMemorySize(size_t newSize) {
 561     if (!isFileValid()) {
 563         return false;
 564     }
 565 
 566     if (newSize >= m_output->spaceLeft()) { //内存不够
 568         static const int offset = pbFixed32Size(0);
 569         MMBuffer data = MiniPBCoder::encodeDataWithObject(m_dic); //重写数据,防止过多的修改和删除导致占用过多的内存空间,如redis的rewrite aof
 570         size_t lenNeeded = data.length() + offset + newSize;
 571         if (m_isAshmem) {
 572             if (lenNeeded > m_size) {//重写后还不够
 575                 return false;
 576             }
 577         } else {
 578             size_t futureUsage = newSize * std::max(8, (m_dic.size() + 1) / 2);
 581             if (lenNeeded >= m_size || (lenNeeded + futureUsage) >= m_size) {
 582                 size_t oldSize = m_size;
 583                 do {
 584                     m_size *= 2;
 585                 } while (lenNeeded + futureUsage >= m_size); //内存空间增长策略
 589 
 590                 // if we can't extend size, rollback to old state
 591                 if (ftruncate(m_fd, m_size) != 0) {
 594                     m_size = oldSize;
 595                     return false;
 596                 } //调整文件大小成功
 597                 if (!zeroFillFile(m_fd, oldSize, m_size - oldSize)) {
 600                     m_size = oldSize;
 601                     return false;
 602                 } //初始化多出来的内存为0
 603 
 604                 if (munmap(m_ptr, oldSize) != 0) {
 606                 }//munmap的时候把共享内存中的数据写到文件,跟手动调用msync效果一样
 607                 m_ptr = (char *) mmap(m_ptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0); //重新mmap
 608                 if (m_ptr == MAP_FAILED) {
 610                 }
 611 
 612                 // check if we fail to make more space
 613                 if (!isFileValid()) {
 615                     return false;
 616                 }
 617             }
 618         }
 619 
 620         if (m_crypter) { //校验相关
 621             m_crypter->reset();
 622             auto ptr = (unsigned char *) data.getPtr();
 623             m_crypter->encrypt(ptr, ptr, data.length());
 624         }
 625 
 626         writeAcutalSize(data.length());
 627 
 628         delete m_output;
 629         m_output = new CodedOutputData(m_ptr + offset, m_size - offset);
 630         m_output->writeRawData(data); //写rewrite后的数据
 631         recaculateCRCDigest();
 632     }
 633     return true;
 634 }

删除:

1123 void MMKV::removeValueForKey(const std::string &key) {
1124     if (key.empty()) {
1125         return;
1126     }
1127     SCOPEDLOCK(m_lock);
1128     SCOPEDLOCK(m_exclusiveProcessLock); //写锁
1129     checkLoadData(); //数据是否是最新
1130 
1131     removeDataForKey(key);
1132 }

 674 bool MMKV::removeDataForKey(const std::string &key) {
 675     if (key.empty()) {
 676         return false;
 677     }
 678 
 679     auto deleteCount = m_dic.erase(key);
 680     if (deleteCount > 0) {
 681         static MMBuffer nan(0);  //删除标志
 682         return appendDataWithKey(nan, key);  ;//append(同写)
 683     }
 684 
 685     return false;
 686 }

持久化:

1154 void MMKV::sync() {
1155     SCOPEDLOCK(m_lock);
1156     if (m_needLoadFromFile || !isFileValid()) {
1157         return;
1158     }
1159     SCOPEDLOCK(m_exclusiveProcessLock);
1160     if (msync(m_ptr, m_size, MS_SYNC) != 0) {
1162     }
1163 }

这块一方面是由程序手动调用的,但是在MMKV::onExit的时候。

这里有几处设计思路可以学习下,一是如redis中的aof重写,一开始只管写,当文件达到一定大小后,把当前m_dic快照rewrite下,删除重复的对一个key的操作,以最后一个为准,相当于延迟计算。还有如leveldb中对key的删除,不真正删除,只设置一个特殊标志,当合并的时检查并作删除,这时rewrite的时候以m_dic为准,当然需要保证正常的key中不会含有特殊标志。

另外在recaculateCRCDigest中会对序列号自增IncreaseSequence=true,其他进程会重新mmap。在几处可能会发起这个调用:fullWriteback/loadFromFile/ensureMemorySize

 882 void MMKV::recaculateCRCDigest() {
 883     if (m_ptr && m_ptr != MAP_FAILED) {
 884         m_crcDigest = 0;
 885         constexpr int offset = pbFixed32Size(0);
 886         updateCRCDigest((const uint8_t *) m_ptr + offset, m_actualSize, IncreaseSequence);
 887     }
 888 }

其他的一些实现不多分析了,用到的时候再看看。这里删除和修改只是简单的在文件后面append,之后用后面的覆盖前面的,每次读写和其他接口,都要尝试是否重新load最新的数据。

总结下:这个开源项目涉及到的知识点有多进程通信共享内存,文件锁同步,递归锁,锁的升降级等和一些不错的设计实现。当然里面还有一些注意点,基础知识不扎实可能会出踩坑。
当然最重要的是根据相应的业务需求来选择适合的方案。

参考
msync
MMKV for Android 多进程设计与实现

你可能感兴趣的:(mmkv框架源码浅析(下))