[Android]高效能MMKV資料互動分析-MMKV初始化

Cang_Wang發表於2019-02-27

大家好,我係蒼王。 以下是我這個系列的相關文章,有興趣可以參考一下,可以給個喜歡或者關注我的文章。

[Android]如何做一個崩潰率少於千分之三噶應用app--章節列表

Android元件化架構熱賣中

元件化群1已經滿員,進來的可以加群2 763094035

MMKV框架初始化

    MMKV.initialize(this);

    public static String initialize(Context context) {
        //建立儲存目錄
        rootDir = context.getFilesDir().getAbsolutePath() + "/mmkv";
        initialize(rootDir);
        return rootDir;
    }

    private static native void initialize(String var0);

複製程式碼

之後是呼叫jni中的操作了

extern "C" JNIEXPORT JNICALL void
Java_com_tencent_mmkv_MMKV_initialize(JNIEnv *env, jobject obj, jstring rootDir) {
    //c++中大於0和非空都是為真 
    if (!rootDir) {
        return;
    }

    //string轉為char*
    const char *kstr = env->GetStringUTFChars(rootDir, nullptr);
    if (kstr) {
        MMKV::initializeMMKV(kstr);
        //初始化完後釋放kstr
        env->ReleaseStringUTFChars(rootDir, kstr);
    }
}

複製程式碼

MMKV初始化, pthread_once()函式詳解

在多執行緒環境中,有些事僅需要執行一次。通常當初始化應用程式時,可以比較容易地將其放在main函式中。但當你寫一個庫時,就不能在main裡面初始化了,你可以用靜態初始化,但使用一次初始化(pthread_once)會比較容易些。

int pthread_once(pthread_once_t *once_control, void (*init_routine) (void));

功能:本函式使用初值為PTHREAD_ONCE_INIT的once_control變數保證init_routine()函式在本程式執行序列中僅執行一次。

在多執行緒程式設計環境下,儘管pthread_once()呼叫會出現在多個執行緒中,init_routine()函式僅執行一次,究竟在哪個執行緒中執行是不定的,是由核心排程來決定。 那麼initialize方法只會執行一次。

void MMKV::initializeMMKV(const std::string &rootDir) {
    //程式控制
    static pthread_once_t once_control = PTHREAD_ONCE_INIT;
    //程式中只執行一次initialize
    pthread_once(&once_control, initialize);
    //儲存檔案地址
    g_rootDir = rootDir;
    //strdup字串拷貝
    //c_str()函式返回一個指向正規C字串的指標, 內容與本string串相同.這是為了與c語言相容,在c語言中沒有string型別,故必須通過string類物件的成員函式c_str()把string 物件轉換成c中的字串樣式。注意:一定要使用strcpy()函式 等來操作方法c_str()返回的指標
    //需要分配空間的
    char *path = strdup(g_rootDir.c_str());
    //建立MmapedFile
    mkPath(path);
    //清除地址空間
    free(path);

    MMKVInfo("root dir: %s", g_rootDir.c_str());
}

void initialize() { 
    //建立雜湊表<id,mmkv>
   // 使用unordered_map優點因為內部實現了雜湊表,因此其查詢速度非常的快 ,缺點雜湊表的建立比較耗費時間
    g_instanceDic = new unordered_map<std::string, MMKV *>;
    //初始化執行緒鎖
    g_instanceLock = ThreadLock();

    //testAESCrypt();

    MMKVInfo("page size:%d", DEFAULT_MMAP_SIZE);
}
//使用getpagesize函式獲得一頁記憶體大小
//系統給我們提供真正的記憶體時,用頁為單位提供,一次最少提供一頁的真實記憶體空間
 //分配記憶體空間:你真實的分配了多少記憶體,就使用多少記憶體,不要越界使用
 //但是系統提供的真實記憶體空間是以頁來提供的。
const int DEFAULT_MMAP_SIZE = getpagesize();

複製程式碼

建立儲存的資料夾,遍歷地址名,然後迴圈建立

bool mkPath(char *path) {
    //檔案(夾)資訊結構體
    struct stat sb = {};
    bool done = false;
    char *slash = path;

    while (!done) {
        //拿出資料夾名
        slash += strspn(slash, "/");
        slash += strcspn(slash, "/");
        //遍歷到最尾部
        done = (*slash == '\0');
        *slash = '\0';
        //如果資料夾不為空
        if (stat(path, &sb) != 0) {
            //建立資料夾
            if (errno != ENOENT || mkdir(path, 0777) != 0) {
                MMKVWarning("%s", path);
                return false;
            }
        } else if (!S_ISDIR(sb.st_mode)) {  //如果不是資料夾,拋錯誤
            MMKVWarning("%s: %s", path, strerror(ENOTDIR));
            return false;
        }

        *slash = '/';
    }

    return true;
}

複製程式碼

儲存檔案初始化

    //需要填寫mmapId,執行緒(單執行緒,多執行緒),加密金鑰
    MMKV.mmkvWithID(mmapID, MMKV.SINGLE_PROCESS_MODE, cryptKey);

    public static MMKV mmkvWithID(String mmapID, int mode, String cryptKey) {
        if(rootDir == null) {  //如果主目錄未初始化丟擲異常
            throw new IllegalStateException("You should Call MMKV.initialize() first.");
        } else {
            //id 不能超過46個位元組
            verifyMMID(mmapID); 
            創立出jni中分配的ID
            long handle = getMMKVWithID(mmapID, mode, cryptKey);
            return new MMKV(handle);
        }
    }
    //mmkv的id是long型別
    private static native long getMMKVWithID(String var0, int var1, String var2);

複製程式碼
extern "C" JNIEXPORT JNICALL jlong Java_com_tencent_mmkv_MMKV_getMMKVWithID(
    JNIEnv *env, jobject obj, jstring mmapID, jint mode, jstring cryptKey) {
    MMKV *kv = nullptr;  //初始化為空指標
    if (!mmapID) {  //如果為空,直接返回空指標
        return (jlong) kv;  
    }
    string str = jstring2string(env, mmapID);  //格式化mmapId

    if (cryptKey != nullptr) {
        string crypt = jstring2string(env, cryptKey);  //格式化金鑰
        if (crypt.length() > 0) { 
            //建立檔案,大小為一頁,和加密金鑰
            kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, &crypt);
        }
    }
    if (!kv) {  //如果建立失敗,重新建立一個不加密的檔案
        kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, nullptr);
    }

    return (jlong) kv;
}

MMKV *MMKV::mmkvWithID(const std::string &mmapID, int size, MMKVMode mode, string *cryptKey) {
    //如果mmapId為空範圍空指標
    if (mmapID.empty()) {
        return nullptr;
    }
    //設定單例鎖
    SCOPEDLOCK(g_instanceLock);
    //在記錄檔案的map中找mampID,對應的mapFile檔案
    auto itr = g_instanceDic->find(mmapID);
    //返回結束位置胡迭代器
    //如果已經存在
    if (itr != g_instanceDic->end()) {
        //返回現在對應mmkv
        MMKV *kv = itr->second;
        return kv;
    }
    //新建一個mmkv
    auto kv = new MMKV(mmapID, size, mode, cryptKey);
     //儲存到map中
    (*g_instanceDic)[mmapID] = kv;
    return kv;
}

複製程式碼

建立MMKV 初始化

MMKV::MMKV(const std::string &mmapID, int size, MMKVMode mode, string *cryptKey)
    : m_mmapID(mmapID)
    , m_path(mappedKVPathWithID(m_mmapID, mode)) //構建mmkv檔案地址
    , m_crcPath(crcPathWithID(m_mmapID, mode))  //crc檔案
    , m_metaFile(m_crcPath, DEFAULT_MMAP_SIZE, (mode & MMKV_ASHMEM) ? MMAP_ASHMEM : MMAP_FILE) //初始化MmapedFile
    , m_crypter(nullptr)  //加密器
    , m_fileLock(m_metaFile.getFd())  //檔案鎖
    , m_sharedProcessLock(&m_fileLock, SharedLockType)   //程式鎖
    , m_exclusiveProcessLock(&m_fileLock, ExclusiveLockType)  //專用程式鎖
    , m_isInterProcess((mode & MMKV_MULTI_PROCESS) != 0)  //是否多程式
    , m_isAshmem((mode & MMKV_ASHMEM) != 0) {       //是否開啟共享記憶體
    m_fd = -1;
    m_ptr = nullptr;
    m_size = 0;
    m_actualSize = 0;
    m_output = nullptr;

    if (m_isAshmem) { //如果需要共享記憶體,需要使用建立共享共享記憶體的MmapedFile
        m_ashmemFile = new MmapedFile(m_mmapID, static_cast<size_t>(size), MMAP_ASHMEM);
        //讀取匿名記憶體的檔案fd地址
        m_fd = m_ashmemFile->getFd();
    } else {
        m_ashmemFile = nullptr;
    }

    if (cryptKey && cryptKey->length() > 0) { //是否存在加密金鑰,存在則建立AES加密器
        m_crypter = new AESCrypt((const unsigned char *) cryptKey->data(), cryptKey->length());
    }
    //是否直接衝檔案載入
    m_needLoadFromFile = true;

    m_crcDigest = 0;
    //是否開啟程式鎖
    m_sharedProcessLock.m_enable = m_isInterProcess;
    //是否開啟專用程式鎖
    m_exclusiveProcessLock.m_enable = m_isInterProcess;

    // sensitive zone
    {
         //單例鎖
        SCOPEDLOCK(m_sharedProcessLock);
        loadFromFile();
    }
}

複製程式碼

讀取檔案

void MMKV::loadFromFile() {
    if (m_isAshmem) {  //是否使用匿名記憶體,是則初始化匿名記憶體
        loadFromAshmem();
        return;
    }

    m_metaInfo.read(m_metaFile.getMemory());
   //開啟檔案,m_fd檔案描述符
    m_fd = open(m_path.c_str(), O_RDWR | O_CREAT, S_IRWXU);  
    if (m_fd < 0) {  //檔案不存在
        MMKVError("fail to open:%s, %s", m_path.c_str(), strerror(errno));
    } else {
        m_size = 0;
        struct stat st = {0};
        if (fstat(m_fd, &st) != -1) { //檔案狀態是否可讀
            m_size = static_cast<size_t>(st.st_size);
        }
        // round up to (n * pagesize)
        if (m_size < DEFAULT_MMAP_SIZE || (m_size % DEFAULT_MMAP_SIZE != 0)) { //檔案大小有內容,且小於1頁
            size_t oldSize = m_size;
            m_size = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
            if (ftruncate(m_fd, m_size) != 0) {  //指定檔案大小輸出是否可行
                MMKVError("fail to truncate [%s] to size %zu, %s", m_mmapID.c_str(), m_size,
                          strerror(errno));
                m_size = static_cast<size_t>(st.st_size);
            }
            zeroFillFile(m_fd, oldSize, m_size - oldSize); //清空檔案
        }
         //將檔案對映到記憶體
        m_ptr = (char *) mmap(nullptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
        //之後操作和匿名記憶體中操作相同
        if (m_ptr == MAP_FAILED) {
            MMKVError("fail to mmap [%s], %s", m_mmapID.c_str(), strerror(errno));
        } else {
            memcpy(&m_actualSize, m_ptr, Fixed32Size);
            MMKVInfo("loading [%s] with %zu size in total, file size is %zu", m_mmapID.c_str(),
                     m_actualSize, m_size);
            bool loaded = false;
            if (m_actualSize > 0) {
                if (m_actualSize < m_size && m_actualSize + Fixed32Size <= m_size) {
                    if (checkFileCRCValid()) {
                        MMKVInfo("loading [%s] with crc %u sequence %u", m_mmapID.c_str(),
                                 m_metaInfo.m_crcDigest, m_metaInfo.m_sequence);
                        MMBuffer inputBuffer(m_ptr + Fixed32Size, m_actualSize, MMBufferNoCopy);
                        if (m_crypter) {
                            decryptBuffer(*m_crypter, inputBuffer);
                        }
                        //初始化Photobuf儲存結構orderedMap
                        m_dic = MiniPBCoder::decodeMap(inputBuffer);
                        m_output = new CodedOutputData(m_ptr + Fixed32Size + m_actualSize,
                                                       m_size - Fixed32Size - m_actualSize);
                        loaded = true;
                    }
                }
            }
            if (!loaded) {
                SCOPEDLOCK(m_exclusiveProcessLock);

                if (m_actualSize > 0) {
                    writeAcutalSize(0);
                }
                m_output = new CodedOutputData(m_ptr + Fixed32Size, m_size - Fixed32Size);
                recaculateCRCDigest();
            }
            MMKVInfo("loaded [%s] with %zu values", m_mmapID.c_str(), m_dic.size());
        }
    }

    if (!isFileValid()) {
        MMKVWarning("[%s] file not valid", m_mmapID.c_str());
    }

    m_needLoadFromFile = false;
}

複製程式碼

讀取匿名記憶體

void MMKV::loadFromAshmem() {
    //複製MmapedFile的段地址
    m_metaInfo.read(m_metaFile.getMemory());
    //如果匿名記憶體存在且匿名記憶體檔案為真
    if (m_fd < 0 || !m_ashmemFile) {
        MMKVError("ashmem file invalid %s, fd:%d", m_path.c_str(), m_fd);
    } else {
        //讀取匿名記憶體檔案大小
        m_size = m_ashmemFile->getFileSize();
        //讀取匿名記憶體起始地址
        m_ptr = (char *) m_ashmemFile->getMemory();
        if (m_ptr != MAP_FAILED) {  //如果地址存在
            //複製匿名記憶體出來
            memcpy(&m_actualSize, m_ptr, Fixed32Size);
            MMKVInfo("loading [%s] with %zu size in total, file size is %zu", m_mmapID.c_str(),
                     m_actualSize, m_size);
            bool loaded = false;
            if (m_actualSize > 0) {
                if (m_actualSize < m_size && m_actualSize + Fixed32Size <= m_size) {
                    if (checkFileCRCValid()) {//檢查m_ptr和m_size都設定了
                        MMKVInfo("loading [%s] with crc %u sequence %u", m_mmapID.c_str(),
                                 m_metaInfo.m_crcDigest, m_metaInfo.m_sequence);
                        //創造MMBuffer資料                
                        MMBuffer inputBuffer(m_ptr + Fixed32Size, m_actualSize, MMBufferNoCopy);
                        if (m_crypter) { //如果加密,解密MMBuffer資料
                            decryptBuffer(*m_crypter, inputBuffer);
                        }
                        //               
                        m_dic = MiniPBCoder::decodeMap(inputBuffer);
                        m_output = new CodedOutputData(m_ptr + Fixed32Size + m_actualSize,
                                                       m_size - Fixed32Size - m_actualSize);
                       //標誌已經讀取成功
                        loaded = true;
                    }
                }
            }
            if (!loaded) {
                 //使用範圍鎖
                SCOPEDLOCK(m_exclusiveProcessLock);

                if (m_actualSize > 0) {
                    writeAcutalSize(0);
                }
                //輸出流
                m_output = new CodedOutputData(m_ptr + Fixed32Size, m_size - Fixed32Size);
                //重新計算crc校驗
                recaculateCRCDigest();
            }
            MMKVInfo("loaded [%s] with %zu values", m_mmapID.c_str(), m_dic.size());
        }
    }

    if (!isFileValid()) {
        MMKVWarning("[%s] ashmem not valid", m_mmapID.c_str());
    }

    m_needLoadFromFile = false;
}

複製程式碼

說明一下儲存檔案的建立(分為檔案和共享記憶體)

MmapedFile::MmapedFile(const std::string &path, size_t size, bool fileType)
    : m_name(path), m_fd(-1), m_segmentPtr(nullptr), m_segmentSize(0), m_fileType(fileType) {
    if (m_fileType == MMAP_FILE) {  //檔案建立
        //建立一個檔案
        m_fd = open(m_name.c_str(), O_RDWR | O_CREAT, S_IRWXU);
        if (m_fd < 0) {
            MMKVError("fail to open:%s, %s", m_name.c_str(), strerror(errno));
        } else {
            //檔案屬性的訪問
            struct stat st = {};
            if (fstat(m_fd, &st) != -1) {
                m_segmentSize = static_cast<size_t>(st.st_size);
            }
            if (m_segmentSize < DEFAULT_MMAP_SIZE) {
                m_segmentSize = static_cast<size_t>(DEFAULT_MMAP_SIZE);
                if (ftruncate(m_fd, m_segmentSize) != 0 || !zeroFillFile(m_fd, 0, m_segmentSize)) {
                    MMKVError("fail to truncate [%s] to size %zu, %s", m_name.c_str(),
                              m_segmentSize, strerror(errno));
                    close(m_fd);
                    m_fd = -1;
                    removeFile(m_name);
                    return;
                }
            }
            m_segmentPtr =
                (char *) mmap(nullptr, m_segmentSize, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
            if (m_segmentPtr == MAP_FAILED) {
                MMKVError("fail to mmap [%s], %s", m_name.c_str(), strerror(errno));
                close(m_fd);
                m_fd = -1;
                m_segmentPtr = nullptr;
            }
        }
    } else {
        //共享記憶體建立 #define ASHMEM_NAME_DEF "/dev/ashmem"
        m_fd = open(ASHMEM_NAME_DEF, O_RDWR); 
        if (m_fd < 0) { //建立失敗
            MMKVError("fail to open ashmem:%s, %s", m_name.c_str(), strerror(errno));
        } else {
            if (ioctl(m_fd, ASHMEM_SET_NAME, m_name.c_str()) != 0) {  //記憶體訪問io控制
                MMKVError("fail to set ashmem name:%s, %s", m_name.c_str(), strerror(errno));
            } else if (ioctl(m_fd, ASHMEM_SET_SIZE, size) != 0) {
                MMKVError("fail to set ashmem:%s, size %d, %s", m_name.c_str(), size,
                          strerror(errno));
            } else { //訪問成功
                 //獲取頁長度
                m_segmentSize = static_cast<size_t>(size);
                //獲取頁指標
                m_segmentPtr = (char *) mmap(nullptr, m_segmentSize, PROT_READ | PROT_WRITE,
                                             MAP_SHARED, m_fd, 0);
                if (m_segmentPtr == MAP_FAILED) {
                    MMKVError("fail to mmap [%s], %s", m_name.c_str(), strerror(errno));
                    m_segmentPtr = nullptr;
                } else {
                    return;
                }
            }
            close(m_fd);
            m_fd = -1;
        }
    }
}

複製程式碼

MMKV初始化內容

本節是第1篇,第2~4篇的分析,已經在小專欄裡刊登,請瀏覽https://xiaozhuanlan.com/cangwang_process檢視更詳細的分析.

元件化架構2群

相關文章