NewLife.Redis 100亿数据使用经验技巧分享

2023年6月14日 166次阅读

NewLife.Redis 100亿数据使用经验技巧分享

本文包括Redis入门，基础知识，NewLife.Redis使用，Redis使用技巧，100亿小数据使用经验技巧分享

介绍

NewLife.Redis主要作者及经验介绍来源：大石头
源码： https://github.com/NewLifeX/NewLife.Redis
Nuget：NewLife.Redis
NewLife.Redis是一个Redis客户端组件，以高性能处理大数据实时计算为目标。
Redis协议基础实现Redis/RedisClient位于X组件，包含基础字符串操作。完整实现由独立开源项目NewLife.Redis提供。NewLife.Redis为扩展实现，主要增加列表结构、哈希结构、队列等高级功能。
采取连接池加同步阻塞架构，具有超低延迟（200~600us）以及超高吞吐量的特点。在物流行业大数据实时计算中广泛应有，经过日均100亿次调用量验证。

特性

在ZTO大数据实时计算广泛应用，200多个Redis实例稳定工作一年多，每天处理近1亿包裹数据，日均调用量80亿次
低延迟，Get/Set操作平均耗时200~600us（含往返网络通信）
大吞吐，自带连接池，最大支持1000并发
高性能，支持二进制序列化

基础知识准备

Redis介绍

Redis的意思是REmote DIctionary Server，远程字典服务。
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。
Redis与其他Key-Value存储有何不同
- Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。
- Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，应为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。
Redis其实很简单，最主要的操作是Get和Set，操作的数据就是Key-Value键值对，键为字符串，值是基础数据类型、复杂数据类型

数据类型

字符串（Strings）

字符串是一种最基本的Redis值类型。

列表（Lists）

Redis列表是简单的字符串列表，按照插入顺序排序。

集合（Sets）

Redis集合是一个无序的字符串合集。

哈希（Hashes）

Redis Hashes是字符串字段和字符串值之间的映射，因此它们是表示对象的完美数据类型（例如，具有多个字段的用户，如姓名，姓氏，年龄等）。

有序集合（Sorted sets）

Redis有序集合和Redis集合类似，是非重复的字符串集合。不同之处在于，排序集的每个成员都与得分相关联，用于从最小得分到最高得分排序。虽然成员是独一无二的，但可以重复分数。

其它类型

戳这里查看更多类型

命令

命令大全，方便查询： http://www.redis.cn/commands/
向Redis服务端发送命令，对数据进行操作，客户端只需要发送命令，接收结果

设置 SET

SET key value [EX seconds] [PX milliseconds] [NX|XX]
- EX seconds – 设置键key的过期时间，单位时秒
- PX milliseconds – 设置键key的过期时间，单位时毫秒
- NX – 只有键key不存在的时候才会设置key的值
- XX – 只有键key存在的时候才会设置key的值

获取 GET

GET key

删除 DEL

DEL key [key ...]

搜索 KEYS

KEYS pattern

NewLife.Redis

有了以上知识，那么你就可以很容易地理解NewLife.Redis了
NewLife.Redis实际上就是实现了常用数据类型，发送命令给Redis服务端对数据进行操作

安装

下载安装，默认为6379

一般安装实例在服务器，建议端口号从6001开始，一路排下去，方便计数。

安装完打开命令行窗口，输入redis-cli回车，即可进入redis环境，输入命令可进行Redis操作，如果输入正确的命令，它会自动出现提示，空格后输入下一个参数即可

PS C:\Users\12504> redis-cli
127.0.0.1:6379> KEYS *
(empty list or set)
127.0.0.1:6379> KEYS *
(empty list or set)
127.0.0.1:6379>

连接

连接Redis可以设置密码，有两种写法，可以不用密码和端口
第二个参数是数据库，0-15号，共16个，不写默认是0号

// 实例化Redis，默认端口6379可以省略，密码有两种写法
var ic1 = Redis.Create("127.0.0.1", 7);
var ic2 = Redis.Create("pass@127.0.0.1:6379", 7);
var ic3 = Redis.Create("server=127.0.0.1:6379;password=pass", 7);
ic1.Log = XTrace.Log; // 调试日志。正式使用时注释掉

基础操作

使用之前，进行注册，将FullRedis注册到对象容器，此对象容器2010年就已经存在了。不注册将使用基础Redis，无法使用高级功能
查看说明：使用了日志输出，=>代表执行结果，=>的上一行代表发送到Redis执行的命令。所有时间开头、数字、字母，比如22:32:33.354 1 N - 为NewLife.Caching.Redis自动注册这种格式都是X组件的日志输出格式。

// 激活FullRedis，否则Redis.Create会得到默认的Redis对象
FullRedis.Register();

集合操作的 GetList/GetDictionary/GetQueue/GetSet 四个类型集合，分别代表Redis的列表、哈希、队列、Set集合等。基础版Redis不支持这四个集合，完整版NewLife.Redis支持，MemoryCache则直接支持。

简单操作

执行

XTrace.UseConsole(); // 将操作日志重定向到控制台

// 激活FullRedis，否则Redis.Create会得到默认的Redis对象
FullRedis.Register();

var ic = Redis.Create("127.0.0.1:6379", 3);
ic.Log = XTrace.Log;

// 简单操作
Console.WriteLine("共有缓存对象 {0} 个", ic.Count);

ic.Set("name", "大石头");
Console.WriteLine(ic.Get<String>("name"));

ic.Set("time", DateTime.Now, 1);
Console.WriteLine(ic.Get<DateTime>("time").ToFullString());
Thread.Sleep(1100);
Console.WriteLine(ic.Get<DateTime>("time").ToFullString());

输出

22:32:33.354  1 N - 为NewLife.Caching.Redis自动注册NewLife.Caching.FullRedis
22:32:33.441  1 N - SELECT 3
22:32:33.444  1 N - => OK
22:32:33.446  1 N - FullRedisPool.Init NewLife.Caching.RedisClient Min=2 Max=1000 IdleTime=20s AllIdleTime=120s
22:32:33.446  1 N - FullRedisPool.Acquire Create Free=0 Busy=1
22:32:33.447  1 N - DBSIZE
22:32:33.449  1 N - => 5
共有缓存对象 5 个
22:32:33.456  1 N - SET name 大石头
22:32:33.458  1 N - => OK
22:32:33.459  1 N - GET name
22:32:33.463  1 N - => 大石头
大石头
22:32:33.467  1 N - SETEX time 1 2018-11-12 22:32:33
22:32:33.470  1 N - => OK
22:32:33.472  1 N - GET time
22:32:33.474  1 N - => 2018-11-12 22:32:33
2018-11-12 22:32:33
22:32:34.584  1 N - GET time
0001-01-01 00:00:00

Set方法第一个参数是key；第二个参数是value，可以是任意类型；第三个是过期时间,单位是秒

字符串和字节数组是特殊处理，原封不动传到Redis保存。其它复杂类型默认进行Json序列化，传过去的是Json。所以取回来的时候根据类型处理，字符串或字节数据原样返回，其它复杂类型进行Json反序列化处理。
Set命令一定一定要指定过期时间，不然一直留在内存里很麻烦，宁愿过期后重新写入也不要让它一直留在数据库。

保存对象

执行

    class Program
    {
        static void Main(String[] args)
        {
            XTrace.UseConsole();

            // 激活FullRedis，否则Redis.Create会得到默认的Redis对象
            FullRedis.Register();

            Test5();

            Console.ReadKey();
        }
        class User
        {
            public String Name { get; set; }
            public DateTime CreateTime { get; set; }
        }
        static void Test5()
        {
            var user = new User { Name = "NewLife", CreateTime = DateTime.Now };
            var rds = Redis.Create("127.0.0.1",2);
            rds.Log = XTrace.Log;
            rds.Set("user", user, 3600);
            var user2 = rds.Get<User>("user");
            XTrace.WriteLine("Json: {0}", user2.ToJson());
            XTrace.WriteLine("Json: {0}", rds.Get<String>("user"));
            if (rds.ContainsKey("user")) XTrace.WriteLine("存在！");
            rds.Remove("user");
        }
    }

输出

23:01:36.447  1 N - 为NewLife.Caching.Redis自动注册NewLife.Caching.FullRedis
23:01:36.531  1 N - SELECT 2
23:01:36.534  1 N - => OK
23:01:36.536  1 N - FullRedisPool.Init NewLife.Caching.RedisClient Min=2 Max=1000 IdleTime=20s AllIdleTime=120s
23:01:36.536  1 N - FullRedisPool.Acquire Create Free=0 Busy=1
23:01:36.540  1 N - SETEX user 3600 [53]
23:01:36.544  1 N - => OK
23:01:36.546  1 N - GET user
23:01:36.550  1 N - => [53]
23:01:36.556  1 N - Json: {"Name":"NewLife","CreateTime":"2018-11-12 23:01:36"}
23:01:36.556  1 N - GET user
23:01:36.559  1 N - => [53]
23:01:36.560  1 N - Json: {"Name":"NewLife","CreateTime":"2018-11-12 23:01:36"}
23:01:36.561  1 N - EXISTS user
23:01:36.563  1 N - => 1
23:01:36.564  1 N - 存在！
23:01:36.565  1 N - DEL user
23:01:36.568  1 N - => 1

保存复杂对象时，默认采用Json序列化，所以上面可以按字符串把结果取回来，发现正是Json字符串。Redis的strings，实质上就是带有长度前缀的二进制数据，[53]表示一段53字节长度的二进制数据。
所以这个Set操作，在Redis那边对应的数据类型都是strings。

列表List操作

执行

// 列表
var list = ic.GetList<DateTime>("list");
list.Add(DateTime.Now);
list.Add(DateTime.Now.Date);
list.RemoveAt(1);
Console.WriteLine(list[list.Count - 1].ToFullString());

输出

16:09:44.571  1 N - RPUSH list 2018-11-14 16:09:44
16:09:44.576  1 N - => 5
16:09:44.613  1 N - RPUSH list 2018-11-14 00:00:00
16:09:44.618  1 N - => 6
16:09:44.619  1 N - LINDEX list 1
16:09:44.623  1 N - => 2018-11-12 00:00:00
16:09:44.624  1 N - LREM list 1 2018-11-12 00:00:00
16:09:44.628  1 N - => 1
16:09:44.634  1 N - LLEN list
16:09:44.645  1 N - => 5
16:09:44.646  1 N - LINDEX list 4
16:09:44.651  1 N - => 2018-11-14 00:00:00
2018-11-14 00:00:00

通过GetList返回一个IList结构，这一操作没有向Redis发送命令，只有Add、Remove或者计算Count的时候会向Redis发送命令
用途，举个物联网的栗子：物联网设备源源不断上传数据，如果每次上传数据都写入数据，数据库可能会受不了的，怎么办？这时候就可以把每一条数据放到Redis，放到上面说的List里面，凑到一定程度，然后整批拿出来。比如一分钟来了一万行数据，从Redis里面拿出来，再来个批操作把这些数据一次写入数据库。这个功能XCode有实现，如何提升批操作性能？后面XCode教程会讲。
技巧，key构建：根据自己的数据构造，比如一分钟或者十分钟插入一次，以这个时间为单位，用一个前缀，加上年月日时分作为一个key，新的数据写入新的key。这样在数据写入数据库的时候，新的数据写入新的key，两边都不影响。在数据都写入数据库之后，再通过这个key干掉这一万数据。

字典操作

执行

var dic = ic.GetDictionary<DateTime>("dic");
dic.Add("xxx", DateTime.Now);
Console.WriteLine(dic["xxx"].ToFullString());

输出

17:03:42.526  1 N - HSET dic xxx 2018-11-14 17:03:42
17:03:42.578  1 N - => 0
17:03:42.639  1 N - HGET dic xxx
17:03:42.664  1 N - => 2018-11-14 17:03:42
2018-11-14 17:03:42

GetDictionary方法也是返回IDictionary接口类型变量，此类型适合存对象，比如用户对象，有很多个属性。相比存json，它的优势是按需读取。当对象的属性特别多时，优势更加明显。

队列操作

执行

var mq = ic.GetQueue<String>("queue");
mq.Add(new[] { "abc", "g", "e", "m" });
var arr = mq.Take(3);
Console.WriteLine(arr.Join(","));

输出

17:03:42.710  1 N - RPUSH queue abc g e m
17:03:42.781  1 N - => 9
17:03:42.917  1 N - LPOP queue
17:03:43.096  1 N - => abc
17:03:43.101  1 N - LPOP queue
17:03:43.105  1 N - => g
17:03:43.106  1 N - LPOP queue
17:03:43.118  1 N - => e
abc,g,e

队列其实也是List实现的，这里做了个优化，可以添加一批。示例加了一批数据，也拿了一批。
一个使用场景是消峰、错峰。上下游系统中，上游数据量突然爆发，下游一时处理不了，最简单的方案就是就Redis队列。上游往队列推数据，下游慢慢消费、处理数据。
另一个变态的用途，是可以用来实现跨语言网络通信。所有语言都支持Redis，使用队列，一个接收数据放入队列一个消费数据写入数据库等。比如前面使用go语言，消耗内存少，接收消息推进队列；后面使用C#或者Java从队列拿出来处理业务，写入数据库。这样就实现了跨语言的高效通信，效率极高。此功能虽然没实践过，不过挺好用，有需要的可以试下。

集合操作

执行

var set = ic.GetSet<String>("181110_1234");
set.Add("xx1");
set.Add("xx2");
set.Add("xx3");
Console.WriteLine(set.Count);
Console.WriteLine(set.Contains("xx2"));

输出

17:03:43.129  1 N - SADD 181110_1234 xx1
17:03:43.134  1 N - => 0
17:03:43.140  1 N - SADD 181110_1234 xx2
17:03:43.150  1 N - => 0
17:03:43.166  1 N - SADD 181110_1234 xx3
17:03:43.185  1 N - => 0
17:03:43.191  1 N - SCARD 181110_1234
17:03:43.198  1 N - => 3
3
17:03:43.249  1 N - SISMEMBER 181110_1234 xx2
17:03:43.254  1 N - => 1
True

集合也比较常用，它其实是个Set结构，往里面添加数据，然后判断下是否包含。所以集合比较合适精确判断的去重功能的场景。比如业务上有几千万订单一天，订单号可能会重复，想要统计一下今天一共有多少订单，如果在数据库执行GroupBy分组不太方便，所以业务统计可以用这个Set结构去重，实际使用可能还要更复杂一点。一般我们做五千万级别的去重，所占内存也不少，也就是写入五千万个订单号，后面处理的时候判断一下这个订单号处理过没有。
**实战经验：**有一个功能是快递揽收，就是商家发货了，快递网点要把它收回来，但是收回来之前，网点不知道它有多少货。所以做一个功能，商家发货了就把订单号发到快递公司，以时间和网点编号为key，比如key为上面的181110_1234。也就是编号为1234的网点在18-11-10这天快递公司收到所有的订单都放在这个key里面，然后利用Set结构的去重功能，写过一次的订单不会再次添加，所以订单重复提交都没有问题。这是第一个功能，第二个功能是，网点揽收之后，再告诉快递公司这个单被揽收了，这时候把这个订单从181110_1234这个key里面删掉，最后Set里面剩下的订单，就是18-11-10这天1234网点未揽收订单。
另外，如果网点太多，订单太多，可以用网点id做个哈希，再分摊到32甚至64台Redis上，这样不管多少网点多少订单都可以把数据摊开。
Redis还有个类型HyperLogLogs可以去重，能达到百亿级别，但是有一定几率误判。还有一个去重过滤的是布隆过滤器（Bloom Filter），可用于爬虫url去重等。

批量操作

执行：

var dic = new Dictionary<String, Object>
{
    ["name"] = "NewLife",
    ["time"] = DateTime.Now,
    ["count"] = 1234
};
rds.SetAll(dic, 120);

var vs = rds.GetAll<String>(dic.Keys);
XTrace.WriteLine(vs.Join(",", e => $"{e.Key}={e.Value}"));

结果：

MSET name NewLife time 2018-09-25 15:56:26 count 1234
=> OK
EXPIRE name 120
EXPIRE time 120
EXPIRE count 120
MGET name time count
name=NewLife,time=2018-09-25 15:56:26,count=1234

GetAll/SetAll 在Redis上是很常用的批量操作，同时获取或设置多个key，一般有10倍以上吞吐量。
一次GetAll的时间大概是一次Get的一点几倍，一般建议如果需要两次以上的Get操作，直接用GetAll。

高级操作

Add 添加，当key不存在时添加，已存在时返回false。
Replace 替换，替换已有值为新值，返回旧值。
Increment 累加，原子操作
Decrement 递减，原子操作
Add跟Replace就是实现Redis分布式锁的关键，分布式锁源码：https://github.com/NewLifeX/X/blob/master/NewLife.Core/Caching/CacheLock.cs

执行：

var flag = rds.Add("count", 5678);
XTrace.WriteLine(flag ? "Add成功" : "Add失败");
var ori = rds.Replace("count", 777);
var count = rds.Get<Int32>("count");
XTrace.WriteLine("count由{0}替换为{1}", ori, count);

rds.Increment("count", 11);
var count2 = rds.Decrement("count", 10);
XTrace.WriteLine("count={0}", count2);

结果：

SETNX count 5678
=> 0
Add失败
GETSET count 777
=> 1234
GET count
=> 777
count由1234替换为777
INCRBY count 11
=> 788
DECRBY count 10
=> 778
count=778

性能测试

执行：

var ic = Redis.Create("127.0.0.1:6379", 5);
//var ic = new MemoryCache();
ic.Bench();

输出：

10:39:56.509  1 N - 为NewLife.Caching.Redis自动注册NewLife.Caching.FullRedis
10:39:56.512  1 N - 目标服务器：127.0.0.1:6379/5
10:39:56.514  1 N - FullRedis性能测试[随机]，批大小[100]，逻辑处理器 4 个 3,192MHz-Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz
10:39:56.515  1 N -
10:39:56.515  1 N - 测试 100,000 项，  1 线程
10:39:57.063  1 N - 赋值 100,000 项，  1 线程，耗时     457ms 速度   218,818 ops
10:39:58.227  1 N - 读取 100,000 项，  1 线程，耗时   1,162ms 速度    86,058 ops
10:39:58.854  1 N - 删除 100,000 项，  1 线程，耗时     625ms 速度   160,000 ops
10:39:59.518  1 N - 累加 100,000 项，  1 线程，耗时     662ms 速度   151,057 ops
10:39:59.529  1 N -
10:39:59.536  1 N - 测试 200,000 项，  2 线程
10:40:00.407  1 N - 赋值 200,000 项，  2 线程，耗时     829ms 速度   241,254 ops
10:40:02.110  1 N - 读取 200,000 项，  2 线程，耗时   1,688ms 速度   118,483 ops
10:40:03.244  1 N - 删除 200,000 项，  2 线程，耗时   1,133ms 速度   176,522 ops
10:40:04.502  1 N - 累加 200,000 项，  2 线程，耗时   1,256ms 速度   159,235 ops
10:40:04.502  1 N -
10:40:04.502  1 N - 测试 800,000 项，  8 线程
10:40:07.641  1 N - 赋值 800,000 项，  8 线程，耗时   3,132ms 速度   255,427 ops
10:40:13.937  1 N - 读取 800,000 项，  8 线程，耗时   6,282ms 速度   127,347 ops
10:40:18.735  1 N - 删除 800,000 项，  8 线程，耗时   4,796ms 速度   166,805 ops
10:40:23.519  1 N - 累加 800,000 项，  8 线程，耗时   4,782ms 速度   167,294 ops
10:40:23.523  1 N -
10:40:23.523  1 N - 测试 400,000 项，  4 线程
10:40:24.999  1 N - 赋值 400,000 项，  4 线程，耗时   1,466ms 速度   272,851 ops
10:40:28.035  1 N - 读取 400,000 项，  4 线程，耗时   3,019ms 速度   132,494 ops
10:40:30.318  1 N - 删除 400,000 项，  4 线程，耗时   2,282ms 速度   175,284 ops
10:40:32.694  1 N - 累加 400,000 项，  4 线程，耗时   2,375ms 速度   168,421 ops
10:40:32.695  1 N -
10:40:32.695  1 N - 测试 400,000 项， 64 线程
10:40:34.342  1 N - 赋值 400,000 项， 64 线程，耗时   1,639ms 速度   244,051 ops
10:40:37.460  1 N - 读取 400,000 项， 64 线程，耗时   3,106ms 速度   128,783 ops
10:40:40.201  1 N - 删除 400,000 项， 64 线程，耗时   2,739ms 速度   146,038 ops
10:40:42.737  1 N - 累加 400,000 项， 64 线程，耗时   2,535ms 速度   157,790 ops

测试性能和机器配置有关，Bench方法用不同线程数量分多组进行添删改压力测试，
rand参数设置是否随机读写
batch设置批大小，分批执行操作，借助GetAll/SetAll进行优化
管道，StartPipeline方法开启管道，StopPipeline结束管道，Commit方法提交变更，发送那两个方法中间的所有进入管道的命令。可用AutoPipeline属性，设置自动管道，默认设置100，达到设置值自动提交，无分批时打开管道操作，对添删改优化。

经验技巧总结

抄自源码的README：

在Linux上多实例部署，实例个数等于处理器个数，各实例最大内存直接为本机物理内存，避免单个实例内存撑爆
把海量数据（10亿+）根据key哈希（Crc16/Crc32）存放在多个实例上，读写性能成倍增长
采用二进制序列化，而非常见Json序列化
合理设计每一对Key的Value大小，包括但不限于使用批量获取，原则是让每次网络包控制在1.4k字节附近，减少通信次数
Redis客户端的Get/Set操作平均耗时200~600us（含往返网络通信），以此为参考评估网络环境和Redis客户端组件
使用管道Pipeline合并一批命令
Redis的主要性能瓶颈是序列化、网络带宽和内存大小，滥用时处理器也会达到瓶颈
以上经验，源自于300多个实例4T以上空间一年多稳定工作的经验，并按照重要程度排了先后顺序，可根据场景需要酌情采用！

Redis的兄弟姐妹

Redis实现ICache接口，它的孪生兄弟MemoryCache，内存缓存，千万级吞吐率。各应用强烈建议使用ICache接口编码设计，小数据时使用MemoryCache实现；数据增大（10万）以后，改用Redis实现，不需要修改业务代码。

写在最后

切不可道听途说，不可完全照搬，真假自己试一下就知道啦，试一下比什么都强！
不常用功能没有封装，暂不支持集群，后面一定会支持。

算法网

NewLife.Redis 100亿数据使用经验技巧分享

NewLife.Redis 100亿数据使用经验技巧分享

介绍

特性

基础知识准备

相关资源地址

Redis介绍

数据类型

字符串（Strings）

列表（Lists）

集合（Sets）

哈希（Hashes）

有序集合（Sorted sets）

其它类型

命令

设置 SET

获取 GET

删除 DEL

搜索 KEYS

NewLife.Redis

安装

连接

基础操作

简单操作

保存对象

列表List操作

字典操作

队列操作

集合操作

批量操作

高级操作

性能测试

经验技巧总结

Redis的兄弟姐妹

写在最后