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

发布时间：2025-01-04 04:10

使用Excel的数据透视表，进行数据分析 #生活知识# #生活经验# #软件#

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

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

介绍

NewLife.Redis主要作者及经验介绍来源：大石头源码： https://github.com/NewLifeX/NewLife.Redis Nuget：NewLife.RedisNewLife.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命令大全Redis FAQ 文档项目地址（建议看原版）

Redis安装包：

项目用到的包： http://x.newlifex.com/Redis-x64-3.2.100.msi win安装包：https://github.com/MicrosoftArchive/redis/releases 源码包：http://www.redis.cn/download.html 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>

连接例程位于源码Test项目

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

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.Register();

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

执行

XTrace.UseConsole();

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.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

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);

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实现，不需要修改业务代码。