redis 缓存数据_Redis 缓存数据方案对比：常规 VS 高并发服务器

1 Redis 是什么

Redis 是一种开源的非关系型数据库。起源于负载较大时，当前关系型数据库无法承载的情况。
到目前为止，Redis 可以用作数据库、缓存、消息处理。Redis 可以存储键和5种不同数据结构类型之间的映射，分别为 string(字符串)、hash(散列)、list(列表)、set(集合)、zset(有序集合)。
除此之外，Redis 还可以将存储在内存的键值对持久化到硬盘；使用复制以扩展读性能；还可以使用客户端分片扩展写性能。到目前为止，最新的稳定版本已经更新到 6.0.10。

在本文中，主要围绕 Redis 用作缓存的功能展开。

2 两种服务器缓存数据特点

2.1 常规服务器

访问频率高，且更新频率较低
数据量较大，每次从 db 中读取耗时大

2.2 高并发服务器

访问频率高，且更新频率高

例如秒杀、抢购等活动，商品的库存量在短时间内一直变动

3 缓存内容

针对常规服务器，一般缓存查询条件和查询结果。针对高并发服务器，一般缓存查询/更新频率高的数据行。

4 高并发服务器的设计方案

高并发服务器下，要求数据实时性较高，因此设计了一种重复调度、自动缓存的方案。该算法一直在服务器后台运行，当秒杀活动开始时，算法能够自动的读取数据行，并且每隔一段时间对缓存进行更新(允许不定期)。同时，为达到持续运行的目的，编写守护进程进行缓存。

4.1 使用的数据结构

高并发服务器下的缓存方案借助了 Redis 内置的有序集合(zset)和 string，具体的数据结构分别为 schedule 集合、delay 集合、缓存 string。

schedule 集合
- 作用：决定了缓存调度的顺序。
- score :执行调度的时间戳
- 键 :表名+id
  schedule 集合定义了缓存调度的顺序。重要的数据行先调度，不重要的后调度。即可以根据数据行的优先级进行调度。开发人员可以根据业务优先级灵活的调度数据行。
delay 集合
- 作用：表示每一个键的更新频率。
- score ：延迟值。延迟值 >0 时，表明允许缓存对应的键。延迟值 <=0时，表明不允许缓存对应的键，对应键应从缓存 string 中删除。
- 键：表名+id
  如果 schedule 集合中的时间戳到来，并且 delay 集合中延迟值 >0，那么键对应的内容需要与数据库进行同步，同时 schedule 集合中的时间戳更新为当前时间+延迟值。
缓存 string
- 作用：存放表中 id 和数据行
- 键：表名+id
- 值：db 中对应的数据行
  缓存 string 存储 id 和值的数据结构。通过 schedule 集合和 delay 集合决定缓存是否删除、或者与数据库同步。

4.2 调度算法

4.3 代码实现

创建守护进程

var spawn = require("child_process").spawn;var process = require("process");const cache_row = require("./cache_rows");

var child = spawn("node",["./cache_rows.js"], { detached: true,stdio: [process.stdin,process.stdout,process.stderr]}); console.log("父进程id:" + process.pid, "守护进程id:" + child.pid);console.log("父进程退出！");process.exit(0);

初始化 schedule、delay 集合，延迟默认值为 10ms

/*** 构造cacheList  * @return {*} 表名:[id]*/var getCachelist = async function () {let cachelist = {};for (var item of tablelist) {  await getByTable(item).then((docList) => {    var idList = [];    for (var doc of docList) idList.push(doc["id"]);    cachelist[item] = idList;  });}return cachelist;};

/*** 初始化delay和schedule集合  * @return {*} 无*/var Init_delay_schedule = async function () {var cachelist = await getCachelist();for (var key in cachelist) {  var idList = cachelist[key];  for (var id of idList) {    let currentTime = Date.parse(new Date()) / 1000;    client.zadd("delay", delay.default, key + ":id:" + id, redis.print);    client.zadd("schedule", currentTime + delay.default, key + ":id:" + id, redis.print);  }}

持续进行调度

/*** 使用守护进程,确定是否缓存数据行* @param {*} table 修改的表名 */var cache_row = async function () {  var count = 0;  while (true) {      count++;      client = bluebird.promisifyAll(client);      var currentTime = Date.parse(new Date()) / 1000;

      //取首先到期的数据      var next = await client.zrangeAsync("schedule", 0, -1, "withscores").then((res) => { return res; });      if (next && parseInt(next[1]) > currentTime) {          await sleep(50);      } else {          var item = next[0];          var table = item.split(":")[0];          var row_id = item.split(":")[1];

          var delay = await client.zscoreAsync('delay', item).then((res) => { return res; });          if (delay <= 0)  //移除数据行          {              client.zrem("delay", item);              client.zrem("schedule", item);              client.delete(item);          } else {          //更新数据行              let data = await getById(table, row_id);              data = JSON.stringify(data[0]);

              client.zadd("schedule", currentTime + parseInt(delay), item);              client.set(item, data);          }      }

  }}

注意：node_redis 插件是异步的，而需要同步操作检查缓存是否命中。可使用 bluebird module 将异步操作更改为同步。

5.常规服务器的设计方案

常规服务器的数据特点是查询频率高，且修改频率低。由于所有的用户都会查询该数据，则可以由用户触发。当第一个请求到达时，查询 db，并将查询结果缓存在 redis 中。之后的请求则直接从 redis 中拿到对应数据。

5.1 缓存设置

每次请求到达时，第一步查看缓存。如果缓存未命中，则从数据库中查询，并将查询结果加入到缓存中。

//redis 设置keyvar redisSet = async function(table,cond,res){  var key = table+":"+JSON.stringify(cond);  res = JSON.stringify(res);  await client.setAsync(key,res);}

5.2 缓存查询

每次请求到达时，先从缓存中查询是否已有对应的结果。

//redis 查看缓存是否命中var redisCheck = async function(table,cond){  var key = table+":"+JSON.stringify(cond);  var res =  await client.getAsync(key); // if(res === null) return false;  return res; }

5.3 缓存更新

当缓存的表发生了更新、删除、插入操作，那么 redis 中的数据为脏数据，此时需更新缓存。

//redis 更新缓存var redisUpdate = async function(table){  var keys = await client.keysAsync(table+"*");  for(var key of keys){      var value =  await getDbDataByName(key);      await client.setAsync(key,JSON.stringify(value));  }}

//根据查询条件返回db中数据var getDbDataByName = async function (key){  if(!key) return null;

  let {table,json} = parseKey(key);   json = JSON.parse(json);  let limit = json["limit"];  let pageNum = json["page"];  let orderCondition = json["orderBy"];  let orderType = json["orderType"];  let whereCond = json["where"];

  var model = new BaseModel(table);  var res = await model  .queryByCondition(limit,pageNum,orderCondition,orderType,whereCond);  return  res;}

6.总结

这两种方案各有各的数据特点，并且有各自的应用场景。在选择方案时，最好根据数据的特点和 Redis 的使用定位，选择最合适的方案。

在选择 redis 缓存方案时，由于是 Daemon 首次在实际工程中使用，毫不犹豫的选择了高并发情况下的方案。而在实际项目中，数据特点是查询频率高、更新频率低，因此使用常规服务器下的 Redis 缓存就可以满足条件。Daemon 从中学习了一个道理：技术并不是用的越牛13越好，而是越合适越好