2. 程式人生 > >探索Redis設計與實現9：資料庫redisDb與鍵過期刪除策略

探索Redis設計與實現9：資料庫redisDb與鍵過期刪除策略

阿新 • • 發佈：2019-01-06

一. 資料庫

Redis的資料庫使用字典作為底層實現，資料庫的增、刪、查、改都是構建在字典的操作之上的。 
redis伺服器將所有資料庫都儲存在伺服器狀態結構redisServer(redis.h/redisServer)的db陣列（應該是一個連結串列）裡：

struct redisServer {
  //..
  // 資料庫陣列，儲存著伺服器中所有的資料庫
    redisDb *db;
  //..
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

在初始化伺服器時，程式會根據伺服器狀態的dbnum屬性來決定應該建立多少個數據庫：

struct redisServer {
    // ..
    //伺服器中資料庫的數量
    int dbnum;
    //..
 

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

dbnum屬性的值是由伺服器配置的database選項決定的，預設值為16；

二、切換資料庫原理

每個Redis客戶端都有自己的目標資料庫，每當客戶端執行資料庫的讀寫命令時，目標資料庫就會成為這些命令的操作物件。

127.0.0.1:6379> set msg 'Hello world'
OK
127.0.0.1:6379> get msg
"Hello world"
127.0.0.1:6379> select 2
OK
127.0.0.1:6379[2]> get msg
(nil)
127.0.0.1:6379[2]>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

在伺服器內部，客戶端狀態redisClient結構(redis.h/redisClient)的db屬性記錄了客戶端當前的目標資料庫，這個屬性是一個指向redisDb結構(redis.h/redisDb)的指標：

typedef struct redisClient {
    //..
    // 客戶端當前正在使用的資料庫
    redisDb *db;
    //..
} redisClient;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

redisClient.db指標指向redisServer.db陣列中的一個元素，而被指向的元素就是當前客戶端的目標資料庫。 
我們就可以通過修改redisClient指標，讓他指向伺服器中的不同資料庫，從而實現切換資料庫的功能–這就是select命令的實現原理。 
實現程式碼：

int selectDb(redisClient *c, int id) {
    // 確保 id 在正確範圍內
    if
 
 (id < 0 || id >= server.dbnum)
        return REDIS_ERR;
    // 切換資料庫（更新指標）
    c->db = &server.db[id];
    return REDIS_OK;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

三、資料庫的鍵空間

1、資料庫的結構（我們只分析鍵空間和鍵過期時間）

typedef struct redisDb {
    // 資料庫鍵空間，儲存著資料庫中的所有鍵值對
    dict *dict;                 /* The keyspace for this DB */
    // 鍵的過期時間，字典的鍵為鍵，字典的值為過期事件 UNIX 時間戳
    dict *expires;              /* Timeout of keys with a timeout set */
    // 資料庫號碼
    int id;                     /* Database ID */
    // 資料庫的鍵的平均 TTL ，統計資訊
    long long avg_ttl;          /* Average TTL, just for stats */
    //..
} redisDb
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

這裡寫圖片描述
上圖是一個RedisDb的示例，該資料庫存放有五個鍵值對，分別是sRedis，INums，hBooks，SortNum和sNums，它們各自都有自己的值物件，另外，其中有三個鍵設定了過期時間，當前資料庫是伺服器的第0號資料庫。現在，我們就從原始碼角度分析這個資料庫結構： 
我們知道，Redis是一個鍵值對資料庫伺服器，伺服器中的每一個數據庫都是一個redis.h/redisDb結構，其中，結構中的dict字典儲存了資料庫中所有的鍵值對，我們就將這個字典成為鍵空間。 
Redis資料庫的資料都是以鍵值對的形式存在，其充分利用了字典高效索引的特點。 
a、鍵空間的鍵就是資料庫中的鍵，一般都是字串物件； 
b、鍵空間的值就是資料庫中的值，可以是5種類型物件（字串、列表、雜湊、集合和有序集合）之一。 
資料庫的鍵空間結構分析完了，我們先看看資料庫的初始化。

2、鍵空間的初始化

在redis.c中，我們可以找到鍵空間的初始化操作：

//建立並初始化資料庫結構
 for (j = 0; j < server.dbnum; j++) {
    // 建立每個資料庫的鍵空間
    server.db[j].dict = dictCreate(&dbDictType,NULL);
    // ...
    // 設定當前資料庫的編號
    server.db[j].id = j;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

初始化之後就是對鍵空間的操作了。

3、鍵空間的操作

我先把一些常見的鍵空間操作函式列出來：

// 從資料庫中取出鍵key的值物件，若不存在就返回NULL
robj *lookupKey(redisDb *db, robj *key);

/* 先刪除過期鍵，以讀操作的方式從資料庫中取出指定鍵對應的值物件
 * 並根據是否成功找到值，更新伺服器的命中或不命中資訊,
 * 如不存在則返回NULL，底層呼叫lookupKey函式 */
robj *lookupKeyRead(redisDb *db, robj *key);

/* 先刪除過期鍵，以寫操作的方式從資料庫中取出指定鍵對應的值物件
 * 如不存在則返回NULL，底層呼叫lookupKey函式，
 * 不會更新伺服器的命中或不命中資訊
 */
robj *lookupKeyWrite(redisDb *db, robj *key);

/* 先刪除過期鍵，以讀操作的方式從資料庫中取出指定鍵對應的值物件
 * 如不存在則返回NULL，底層呼叫lookupKeyRead函式
 * 此操作需要向客戶端回覆
 */
robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply);

/* 先刪除過期鍵，以寫操作的方式從資料庫中取出指定鍵對應的值物件
 * 如不存在則返回NULL，底層呼叫lookupKeyWrite函式
 * 此操作需要向客戶端回覆
 */
robj *lookupKeyWriteOrReply(redisClient *c, robj *key, robj *reply);

/* 新增元素到指定資料庫 */
void dbAdd(redisDb *db, robj *key, robj *val);
/* 重寫指定鍵的值 */
void dbOverwrite(redisDb *db, robj *key, robj *val);
/* 設定指定鍵的值 */
void setKey(redisDb *db, robj *key, robj *val);
/* 判斷指定鍵是否存在 */
int dbExists(redisDb *db, robj *key);
/* 隨機返回資料庫中的鍵 */
robj *dbRandomKey(redisDb *db);
/* 刪除指定鍵 */
int dbDelete(redisDb *db, robj *key);
/* 清空所有資料庫，返回鍵值對的個數 */
long long emptyDb(void(callback)(void*));
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

下面我選取幾個比較典型的操作函式分析一下：

查詢鍵值對函式–lookupKey

robj *lookupKey(redisDb *db, robj *key) {
    // 查詢鍵空間
    dictEntry *de = dictFind(db->dict,key->ptr);
    // 節點存在
    if (de) {
        // 取出該鍵對應的值
        robj *val = dictGetVal(de);
        // 更新時間資訊
        if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
            val->lru = LRU_CLOCK();
        // 返回值
        return val;
    } else {
        // 節點不存在
        return NULL;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

新增鍵值對–dbAdd

新增鍵值對使我們經常使用到的函式，底層由dbAdd()函式實現，傳入的引數是待新增的資料庫，鍵物件和值物件，原始碼如下：

void dbAdd(redisDb *db, robj *key, robj *val) {
    // 複製鍵名
    sds copy = sdsdup(key->ptr);
    // 嘗試新增鍵值對
    int retval = dictAdd(db->dict, copy, val);
    // 如果鍵已經存在，那麼停止
    redisAssertWithInfo(NULL,key,retval == REDIS_OK);
    // 如果開啟了叢集模式，那麼將鍵儲存到槽裡面
    if (server.cluster_enabled) slotToKeyAdd(key);
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

好了，關於鍵空間操作函式就分析到這，其他函式(在檔案db.c中)大家可以自己去分析，有問題的話可以回帖，我們可以一起討論！

四、資料庫的過期鍵操作

在前面我們說到，redisDb結構中有一個expires指標（概況圖可以看上圖），該指標指向一個字典結構，字典中儲存了所有鍵的過期時間，該字典稱為過期字典。 
過期字典的初始化：

// 建立並初始化資料庫結構
 for (j = 0; j < server.dbnum; j++) {
        // 建立每個資料庫的過期時間字典
        server.db[j].expires = dictCreate(&keyptrDictType,NULL);
        // 設定當前資料庫的編號
        server.db[j].id = j;
        // ..
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

a、過期字典的鍵是一個指標，指向鍵空間中的某一個鍵物件（就是某一個數據庫鍵）； 
b、過期字典的值是一個long long型別的整數，這個整數儲存了鍵所指向的資料庫鍵的時間戳–一個毫秒精度的unix時間戳。 
下面我們就來分析過期鍵的處理函式：

1、過期鍵處理函式

設定鍵的過期時間–setExpire()

/*
 * 將鍵 key 的過期時間設為 when
 */
void setExpire(redisDb *db, robj *key, long long when) {
    dictEntry *kde, *de;
    // 從鍵空間中取出鍵key
    kde = dictFind(db->dict,key->ptr);
    // 如果鍵空間找不到該鍵，報錯
    redisAssertWithInfo(NULL,key,kde != NULL);
    // 向過期字典中新增該鍵
    de = dictReplaceRaw(db->expires,dictGetKey(kde));
    // 設定鍵的過期時間
    // 這裡是直接使用整數值來儲存過期時間，不是用 INT 編碼的 String 物件
    dictSetSignedIntegerVal(de,when);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

獲取鍵的過期時間–getExpire()

long long getExpire(redisDb *db, robj *key) {
    dictEntry *de;
    // 如果過期鍵不存在，那麼直接返回
    if (dictSize(db->expires) == 0 ||
       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;
    redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
    // 返回過期時間
    return dictGetSignedIntegerVal(de);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

刪除鍵的過期時間–removeExpire()

// 移除鍵 key 的過期時間
int removeExpire(redisDb *db, robj *key) {
    // 確保鍵帶有過期時間
    redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
    // 刪除過期時間
    return dictDelete(db->expires,key->ptr) == DICT_OK;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2、過期鍵刪除策略

通過前面的介紹，大家應該都知道資料庫鍵的過期時間都儲存在過期字典裡，那假如一個鍵過期了，那麼這個過期鍵是什麼時候被刪除的呢？現在來看看redis的過期鍵的刪除策略： 
a、定時刪除：在設定鍵的過期時間的同時，建立一個定時器，在定時結束的時候，將該鍵刪除； 
b、惰性刪除：放任鍵過期不管，在訪問該鍵的時候，判斷該鍵的過期時間是否已經到了，如果過期時間已經到了，就執行刪除操作； 
c、定期刪除：每隔一段時間，對資料庫中的鍵進行一次遍歷，刪除過期的鍵。 
其中定時刪除可以及時刪除資料庫中的過期鍵，並釋放過期鍵所佔用的記憶體，但是它為每一個設定了過期時間的鍵都開了一個定時器，使的cpu的負載變高，會對伺服器的響應時間和吞吐量造成影響。 
惰性刪除有效的克服了定時刪除對CPU的影響，但是，如果一個過期鍵很長時間沒有被訪問到，且若存在大量這種過期鍵時，勢必會佔用很大的記憶體空間，導致記憶體消耗過大。 
定時刪除可以算是上述兩種策略的折中。設定一個定時器，每隔一段時間遍歷資料庫，刪除其中的過期鍵，有效的緩解了定時刪除對CPU的佔用以及惰性刪除對記憶體的佔用。 
在實際應用中，Redis採用了惰性刪除和定時刪除兩種策略來對過期鍵進行處理，上面提到的lookupKeyWrite等函式中就利用到了惰性刪除策略，定時刪除策略則是在根據伺服器的例行處理程式serverCron來執行刪除操作，該程式每100ms呼叫一次。

惰性刪除函式–expireIfNeeded()

原始碼如下：

/* 檢查key是否已經過期，如果是的話，將它從資料庫中刪除 
 * 並將刪除命令寫入AOF檔案以及附屬節點(主從複製和AOF持久化相關)
 * 返回0代表該鍵還沒有過期，或者沒有設定過期時間
 * 返回1代表該鍵因為過期而被刪除
 */
int expireIfNeeded(redisDb *db, robj *key) {
    // 獲取該鍵的過期時間
    mstime_t when = getExpire(db,key);
    mstime_t now;
    // 該鍵沒有設定過期時間
    if (when < 0) return 0;
    // 伺服器正在載入資料的時候，不要處理
    if (server.loading) return 0;
    // lua指令碼相關
    now = server.lua_caller ? server.lua_time_start : mstime();
    // 主從複製相關，附屬節點不主動刪除key
    if (server.masterhost != NULL) return now > when;
    // 該鍵還沒有過期
    if (now <= when) return 0;
    // 刪除過期鍵
    server.stat_expiredkeys++;
    // 將刪除命令傳播到AOF檔案和附屬節點
    propagateExpire(db,key);
    // 傳送鍵空間操作時間通知
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    // 將該鍵從資料庫中刪除
    return dbDelete(db,key);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

定期刪除策略

過期鍵的定期刪除策略由redis.c/activeExpireCycle()函式實現，伺服器週期性地操作redis.c/serverCron()（每隔100ms執行一次）時，會呼叫activeExpireCycle()函式，分多次遍歷伺服器中的各個資料庫，從資料庫中的expires字典中隨機檢查一部分鍵的過期時間，並刪除其中的過期鍵。 
刪除過期鍵的操作由activeExpireCycleTryExpire函式(activeExpireCycle()呼叫了該函式)執行，其原始碼如下：

/* 檢查鍵的過期時間，如過期直接刪除*/
int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
    // 獲取過期時間
    long long t = dictGetSignedIntegerVal(de);
    if (now > t) {
        // 執行到此說明過期
        // 建立該鍵的副本
        sds key = dictGetKey(de);
        robj *keyobj = createStringObject(key,sdslen(key));
        // 將刪除命令傳播到AOF和附屬節點
        propagateExpire(db,keyobj);
        // 在資料庫中刪除該鍵
        dbDelete(db,keyobj);
        // 傳送事件通知
        notifyKeyspaceEvent(NOTIFY_EXPIRED,
            "expired",keyobj,db->id);
        // 臨時鍵物件的引用計數減1
        decrRefCount(keyobj);
        // 伺服器的過期鍵計數加1
        // 該引數影響每次處理的資料庫個數
        server.stat_expiredkeys++;
        return 1;
    } else {
        return 0;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

刪除過期鍵對AOF、RDB和主從複製都有影響，等到了介紹相關功能時再討論。 
今天就先到這裡~

相關推薦

探索Redis設計與實現9：資料庫redisDb與鍵過期刪除策略

一. 資料庫Redis的資料庫使用字典作為底層實現，資料庫的增、刪、查、改都是構建在字典的操作之上的。 redis伺服器將所有資料庫都儲存在伺服器狀態結構redisServer(redis.h/redisServer)的db陣列（應該是一個連結串列）裡：struct redisServer { //..

探索Redis設計與實現12：淺析Redis主從複製

摘要早期的RDBMS被設計為執行在單個CPU之上，讀寫操作都由經單個數據庫例項完成，複製技術使得資料庫的讀寫操作可以分散在運行於不同CPU之上的獨立伺服器上，Redis作為一個開源的、優秀的key-value快取及持久化儲存解決方案，也提供了複製功能，本文主要介紹Redis的

Redis 設計與實現[2] -- 單機資料庫的實現

1 鍵空間 set message "hello word" rpush alphabet "a" "b" "c" hset book name "Redis in action" hset book author "Josian L. Carlson" hset book publisher

《redis設計與實現》2-資料庫實現篇

上一篇文章介紹了redis基本的資料結構和物件《redis設計與實現》1-資料結構與物件篇 本文主要關於： redis資料庫實現的介紹 前面介紹的各種資料，在redis伺服器中的記憶體模型是什麼樣的的。 RDB檔案將這些記憶體資料持久化後的格式是什麼樣的 RDB和AOF序列化的區別是什麼

Redis 設計與實現 3：字串 SDS

> 本文的分析沒有特殊說明都是基於 Redis 6.0 版本原始碼 > redis 6.0 原始碼：https://github.com/redis/redis/tree/6.0 在 Redis 中，字串都用自定義的結構**簡單動態字串(Simple Dynamic Strings，SDS)**。 Redi

Redis 設計與實現 4：字典

Redis 中，字典是基礎結構。Redis 資料庫資料、過期時間、雜湊型別都是把字典作為底層結構。 # 字典的結構 ## 雜湊表 雜湊表的實現程式碼在：`dict.h/dictht `，Redis 的字典用雜湊表的方式實現。 ```c typedef struct dictht { // 雜湊表陣列，俗稱

Redis 設計與實現 5：壓縮列表

壓縮列表是 ZSET、HASH和 LIST 型別的其中一種編碼的底層實現，是由一系列特殊編碼的連續記憶體塊組成的順序型資料結構，其目的是節省記憶體。 # ziplist 的結構 ## 外層結構 下圖展示了壓縮列表的組成： ![ziplist 的結構](https://img-blog.csdnimg.cn/

Redis 設計與實現 5：壓縮列表 ziplist

壓縮列表是 ZSET、HASH和 LIST 型別的其中一種編碼的底層實現，是由一系列特殊編碼的連續記憶體塊組成的順序型資料結構，其目的是節省記憶體。 # ziplist 的結構 ## 外層結構 下圖展示了壓縮列表的組成： ![ziplist 的結構](https://img-blog.csdnimg.cn/

Redis 設計與實現 6：五大資料型別之字串

前文 [Redis 設計與實現 2：Redis 物件](https://www.cnblogs.com/chenchuxin/p/14187921.html) 說到，五大資料型別都會封裝成 `RedisObject`。 ```c typedef struct redisObject { unsigne

Redis 設計與實現 8：五大資料型別之雜湊

雜湊物件的編碼有兩種：`ziplist`、`hashtable`。 ## 編碼一：ziplist `ziplist` 已經是我們的老朋友了，它一出現，那肯定就是為了節省記憶體啦。那麼雜湊物件是怎麼用 `ziplist` 儲存的呢？ 每次插入鍵值對的時候，在 `ziplist` 列表末尾，挨著插入 `fiel

《redis設計與實現》1-資料結構與物件篇

前言 redis效能為什麼這麼出色？它與其他快取中介軟體有什麼區別？ redis底層使用了哪些資料結構支撐它如此高效的效能？ 內部豐富的資料型別底層為什麼都使用至少兩種資料結構實現？分別是什麼？ 如果合理的使用redis才能發揮它最大的優勢？ 學習完《redis設計與實現》前面關於資

車載環視拼接系統的設計與實現(三)：魚眼畸變校正演算法

       上一部分（車載環視拼接系統的設計與實現(二)）討論的攝像機模型是理想的線性模型，但是在現實中並不存在這樣完全沒有畸變的透鏡，這主要是製造上的原因，因為製作一個球形透鏡比製作一個數學上理想的透鏡更容易，另外從機械製作方面考慮也很難把成像儀和透鏡保持平行的狀態，現實

《Redis設計與實現》讀書筆記——釋出與訂閱、事務、排序、二進位制位陣列

1、釋出與訂閱    釋出與訂閱功能有PUBLISH、SUBSCRIBE、PSUBSCRIBE（正則訂閱，訂閱某個模式）等命令組成。例如SUBSCRIBE "news.it"、PUBLISH "news.it" "hello"、PSUBSCRIBE "news.[ie]t"等

Muduo 設計與實現之一：Buffer 類的設計

陳碩 (giantchen_AT_gmail) 本文介紹 Muduo 中輸入輸出緩衝區的設計與實現。 本文中 buffer 指一般的應用層緩衝區、緩衝技術，Buffer 特指 muduo::net::Buffer class。 Muduo 的 IO 模型 UNPv1

C#設計模式之9：模板方法

like not 存在 als col wan 結構 允許 封裝 模板方法 模板方法是一個方法，定義了算法的步驟，並允許子類為一個或多個步驟提供實現。 本例中用沖泡咖啡和茶的例子來說明： 上圖說明了沖泡咖啡和茶的步驟，可以看出沖泡咖啡和茶的步驟差不多，很相似，先來看看沒有

NETWORK筆記9：預設路由與浮動路由

預設路由：一種特殊的靜態路由，只有從路由表中找不到任何明確匹配的路由條目時，才會使用預設路由。(當訪問Internet時，一些網路出口只有一個，此時沒有必要配置) 浮動路由：配置一個管理距離更大的靜態路由，作為應急出發的備份路徑，在主路由有效的情況下，浮動路由不會出現在路由表中。 實驗名稱：華為路

基於中臺思想的物流系統設計（四）：物流服務與物流詳情

一、概述 在物流系統中，中臺只負責物流訂單的流轉，具體的物流履行往往需要對接第三方快遞公司。由於第三方快遞公司的技術標準不一樣，因此我們需要對第三方快遞公司的介面進行封裝，這裡涉及到兩大類封裝，一個是下發請求的封裝，一個是接收回傳的物流詳情的封裝。對於下發快遞公司，我們不僅僅是介面層面的封裝，而是抽象出了

《Java程式設計》第16週週五：資料庫連線 與 隨機數的使用&&《Java課程實習》日誌（週一）

 第一部分：實驗專案 專案一：隨機相片顯示。 目的：瞭解隨機數的生成，及圖片的顯示。 目標： （1）在已有程式碼的基礎上，完成隨機（或 順序）顯示三張圖片的功能。 （2）當猜測準確，或錯誤時，彈出對話方塊進行迴應。 點選，下載示例相片（示例相片，提取碼為 pufb）。

資料庫設計的六階段：資料庫的設計過程

　6.1　資料庫設計的六階段 　　資料庫設計是建立資料庫及其應用系統的技術，是資訊系統開發和建設中的核心技術。具體說，資料庫設計是指對於一個給定的應用環境，構造最優的資料庫模式，建立資料庫及其應用系統，使之能夠有效地儲存資料，滿足各種使用者的應用需求（資訊要求和處理要求

【乾貨合集】大流量與高併發：資料庫、架構與實踐技巧

2016年9月20-21日20：00-21：30，淘寶開放平臺與阿里云云棲社群將聯合舉辦“大流量高併發網際網路應用實踐線上峰會”，為廣大開發者分享阿里的海量使用者支撐及運營經驗。 報名入口：http://yq.aliyun.com/webinar/join/49?spm=5176.8155509.4376