.NET客户端实现Redis中的管道（PipeLine）与事物（Transactions）

序言

Redis中的管道（PipeLine）特性：简述一下就是，Redis如何从客户端一次发送多个命令，服务端到客户端如何一次性响应多个命令。

Redis使用的是客户端-服务器模型和请求/响应协议的TCP服务器,这就意味着一个请求要有如下步骤才能完成：一、客户端向服务器发送查询命令，而后一般以阻塞的方式等待服务器相应。二、服务器处理查询命令，并将相应发送回客户端。这样便会经过网络链接，若是是本地回环接口那么就能特别迅速的响应，可是若是走外网，甚至外网再作一系列的层层转发，那就显的格外蛋疼。不管网络延时是多少，那么都将占用总体响应的时间。这样一来若是一次发送1个命令，网络延时为100ms，咱们不得不作。那么若是1次发1000个命令，那么网络延时100*1000ms就很难容忍啦。

针对与上面的问题，Redis在2.6版本之后就都提供啦管道（Pipeline）功能。他可使客户端在没有读取旧的响应时，处理新的请求。这样即可以向服务器发送多个命令，而没必要等待答复，直到最后一个步骤中读取答复。这被称为管线（PipeLine），而且是几十年来普遍使用的技术。例如，许多POP3协议实现已经支持此功能，大大加快了从服务器下载新电子邮件的过程。

那么事务这个词汇，常常遇到，就很少唧唧啦，目标要一致就好，即是一组操做怎么作成原子性操做，使他去不了终点，回到原点。

简述wireshark抓包工具

为啦让你们对管线有更形象的感观，这一节咱们先说说Wireshark抓包工具，他会让你看到客户端到服务器经过tcp协议发送的redis命令的过程与详细。

wireshark可以扑捉到系统发送和接受的每个报文，咱们这里只作一些过滤的简述。下图就是他的样子，你打开后能够能够摸索下他的用法。

简述几个过滤规则：

一、ip过滤：目标ip过滤：ip.dst==172.18.8.11,源ip地址过滤：ip.src==192.168.1.12;

二、端口过滤：tcp.port==80，这条规则是把源端口和目的端口为80的都过滤出来。使用tcp.dstport==80只过滤目的端口为80的，tcp.srcport==80只过滤源端口为80的包；

三、协议过滤：直接在fiter框中输入协议名称便可，如：http，tcp，udp，...

四、http模式过滤:过滤get包，http.request.method=="GET",过滤post包，http.request.method=="POST"；

五、若是使用多条件过滤，则须要加链接符号，and。好比 ip.src==192.168.1.12 and http.request.method=="POST" and tcp.srcport==80

StackExchange.Redis实现Redis管线（Pipeline）

上两张图片管线便一目了然啦。

客户端对redis服务器进行屡次请求的话，通常普通模式是这样子的

客户端对redis服务器进行屡次请求的话，管道模式是这样子的

通常模式咱们上代码：

 public static void GetNoPipelining()
        {
            for (var i = 0; i < 3; i++)
            {
                var key = "name:" + i;
                db.StringAppend(key, "张龙豪");
            }
        }

查看tcp请求报文的data

这样你本身作的过程当中，能够看到我圈起来的3个tcp请求的key分别为name：0，name:1,name:2这样子。

那么咱们使用管道模式

 public static void GetPipelining()
        {
            var batch = db.CreateBatch();
            for (int i = 0; i < 3; i++)
            {
                var key = "mename:" + i;
                batch.StringAppendAsync(key, "张龙豪");
            }
            batch.Execute();
        }

再来看下请求

这样很明显就能看出来是1个请求发送出来啦多个命令。那么咱们不用createBatch（）也是能够实现这样的效果的。

            var a = db.StringAppendAsync("zlh:1", "zhanglonghao1");
            var b = db.StringAppendAsync("zlh:2", "zhanglonghao2");
            var c = db.StringAppendAsync("zlh:3", "zhanglonghao3");
            var aa = db.Wait(a);
            var bb = db.Wait(a);
            var cc = db.Wait(a);

在接下来咱们作一个简单的性能比较。代码以下：

  static void Main(string[] args)
        {
            Stopwatch watch = new Stopwatch();
            Stopwatch watch1 = new Stopwatch();
            watch.Start();
            GetNoPipelining();
            Console.WriteLine("通常循环耗时：" + watch.ElapsedMilliseconds);
            watch.Stop();
            watch1.Start();
            GetPipelining();
            Console.WriteLine("Pipelining插入耗时：" + watch1.ElapsedMilliseconds);
            watch1.Stop();
            Console.ReadLine();
        }

        public static void GetNoPipelining()
        {
            for (var i = 0; i < 5000; i++)
            {
                var key = "name:" + i;
                db.StringAppend(key, "张龙豪");
            }
        }
        public static void GetPipelining()
        {
            var batch = db.CreateBatch();
            for (int i = 0; i < 5000; i++)
            {
                var key = "mename:" + i;
                batch.StringAppendAsync(key, "张龙豪");
            }
            batch.Execute();
        }

结果以下：

到此我还要说一下StackExchange.Redis的三种命令模式，其中使用2和3的模式发送命令，会默认被封装在管道中，不信的话，你能够作个小demo测试下：

一、sync：同步模式，会直接阻塞调用者，但不会阻塞其余线程。

二、async：异步模式，使用task模型封装。

三、fire-and-forget：发送命令，而后彻底不关心最终何时完成命令操做。在Fire-and-Forget模式下,全部命令都会当即获得返回值，该值都是该返回值类型的默认值,好比操做返回类型是bool将会当即获得false,由于false = default(bool)。

此节参考redis官方文档与StackExchange.Redis官方文档，链接以下：

https://redis.io/topics/pipelining

https://github.com/StackExchange/StackExchange.Redis/blob/master/Docs/PipelinesMultiplexers.md

StackExchange.Redis实现Redis事务（Transactions）

这个看官方文档，我只能说实现的很奇怪吧。我先描述下个人环境，就是准备一个空redis库，而后一步一步往下走，咱们写代码看结果，来搞一搞这个事务。

 static void Main(string[] args)
        {
            var tran = db.CreateTransaction();
            tran.AddCondition(Condition.ListIndexNotEqual("zlh:1",0,"zhanglonghao"));        
            tran.ListRightPushAsync("zlh:1", "zhanglonghao"); 
            bool committed = tran.Execute();
            Console.WriteLine(committed);
            Console.ReadLine();
        }

执行结果为：true。数据库中结果以下，说明咱们插入成功。

即：若是key为：zlh：1的list集合在索引0初的value!=zhanglonghao的话，咱们从链表右侧插入一条数据key为zlh：1value为zhanglonghao，成功。由于第一次操做为空库。0处确实不为张龙豪。

数据不清空，继续上代码。

 static void Main(string[] args)
        {
            var tran = db.CreateTransaction();
            tran.AddCondition(Condition.ListIndexNotEqual("zlh:1",0,"zhanglonghao"));        
            tran.ListRightPushAsync("zlh:1", "zhanglonghao1");           
            bool committed = tran.Execute();
            Console.WriteLine(committed);
            Console.ReadLine();
        }

结果为false，数据库没有增减数据。已久与上图的数据保持一致。

缘由分析：0处此时为zhanglonghao，因此ListIndexNotEqual("zlh:1",0,"zhanglonghao")为假命题，直接回滚，不执行下面的插入命令。

数据不清空，继续上代码：

 static void Main(string[] args)
        {
            var tran = db.CreateTransaction();
            tran.AddCondition(Condition.ListIndexEqual("zlh:1",0,"zhanglonghao"));        
            tran.ListRightPushAsync("zlh:1", "zhanglonghao1");           
            bool committed = tran.Execute();
            Console.WriteLine(committed);
            Console.ReadLine();
        }

结果为true，数据结果以下，增加一条值为zhanglonghao1的数据：

缘由分析：ListIndexEqual("zlh:1",0,"zhanglonghao")为真命题，执行下面的操做，提交事物。

数据不删继续上代码：

static void Main(string[] args)
        {
            var tran = db.CreateTransaction();
            tran.AddCondition(Condition.ListIndexEqual("zlh:1",0,"zhanglonghao"));        
            tran.ListRightPushAsync("zlh:1", "zhanglonghao2");
            tran.AddCondition(Condition.ListIndexNotEqual("zlh:1", 0, "zhanglonghao"));
            tran.ListRightPushAsync("zlh:1", "zhanglonghao3");
            bool committed = tran.Execute();
            Console.WriteLine(committed);
            Console.ReadLine();
        }

结果为false，数据库数据已久与上面的保持一致，不增不减。

分析缘由：Condition.ListIndexEqual("zlh:1",0,"zhanglonghao")为true，可是到下面的ListIndexNotEqual("zlh:1", 0, "zhanglonghao")为false。故整个事物的操做回滚，不予执行，故数据库没有变化。

到此，我就不写多余的代码啦，但我要说几个注意点：

一、执行命令的操做需为异步操做。

二、在事物中执行的命令，都不会直接看到结果，故此结果也不能用于下面代码作判断，由于当前的异步命令在Execute()以前是不会对数据库产生任何影响的。

三、参考文档：https://github.com/StackExchange/StackExchange.Redis/blob/master/Docs/Transactions.md

总结

接下来是你们最喜欢的总结内容啦，内容有二，以下：

一、但愿能关注我其余的文章。

二、博客里面有没有很清楚的说明白，或者你有更好的方式，那么欢迎加入左上方的2个交流群，咱们一块儿学习探讨。