Redis缓存NoSQL

下面是一些关于Redis比较好的文章，因为篇幅较大，我就将其折叠起来了。不太喜欢分不同的笔记去记载，除非真的很多很多。所以本文不仅要对Redis做简单的介绍，还要分别介绍Redis中的五种结构，并会贴上一些示例代码，因为篇幅比较大，所以示例代码都是折叠起来的，有需要看代码的请自行点开，还请谅解。这里只附上了不分示例代码。

redis.conf配置详细解析https://www.cnblogs.com/kreo/p/4423362.html
项目首页，下方是各种语言支持列表：

http://code.google.com/p/redis/

作者在wiki中给出了一个非常好的例子，以使我们可以快速上手，地址：

http://code.google.com/p/redis/wiki/TwitterAlikeExample

同时作者推荐的另一个教程，地址：

http://labs.alcacoop.it/doku.php?id=articles:redis_land

一个redis爱好者创建的相关问题讨论网站：

http://www.rediscookbook.org/

为什么使用 Redis及其产品定位

http://www.infoq.com/cn/articles/tq-why-choose-redis

Redis内存使用优化与存储

http://www.infoq.com/cn/articles/tq-redis-memory-usage-optimization-storage

https://www.linuxidc.com/Linux/2011-02/32700.htm

本地缓存，当前进程的内存，把数据存起来，下次直接使用，可以提升效率。

　　1、容量有限，window下面，32位一个进程最多2G或者3G，64位最多也就4G

　　2、多服务器直接需要缓存共享，需要分布式缓存，远程服务器内存管理数据，提供读写接口，效率高。

分布式缓存：

　　1、Memcached，最早流行的

　　2、Redis（NoSQL）现在的主流方案

为什么现在都升级到Redis（NoSQL）去了？

　　NoSQL：

　　　　非关系型数据库，Not Only SQL

　　　　web1.0时代，服务端提供数据，客户端看，只能看新闻

　　　　web2.0时代，客户端可以向服务端互动了，现在能评论了

　　　　数据的关系负责：

　　　　　　好友关系（张三有100个好友，映射表，其实这个映射表就荣誉了，关系型数据库开始累赘了）

　　　　　　再就是数据库读取和写入压力，硬盘的速度满足不了，尤其是一些大数据量，所以产生了NoSQL。

　　　　特点：基于内存（MongoDB是基于文档的），没有严格的数据格式，不是一行数据的列必须一样。封堵的类型，满足web2.0的需求。

　　　　Redis和MongoDB都是NoSQL，应该在什么场景去选择呢？数据量比较大，用MongoDB，否则其他的一切需求，用Redis就可以解决。

　　Redis：REmote DIctionary Server，远程点点服务器，基于内存管理（数据存在内存），实现了五种数据结构（String、HashTable、Set、ZSet、List去分别对应各种具体需求），单线程模型应用程序（单进程单线程），对外提供插入-查询-固化-集群功能。

　　Redis----SQLServer

　　Redis-Cli---SQLClient

　　Redis支持N多个命令，相当于SQL语句

　　ServerStack（1小时6000次请求）----ADO.NET

　　StackExchange，免费的，其实更像是ORM，封装了连接+命令。

https://github.com/dmajkic/redis/downloads 下载地址

管理员模式打开控制台(配置成自己的路径)

可以打开redis-cli.exe尝试使用，
输入：set key value 
结果：OK
输入：get key 
结果：value

 Redis安装与启动，以及可视化管理工具，请参考：https://blog.csdn.net/lihua5419/article/details/80661684

用cli，可以简单的对Redis数据新增和获取

 

 　　基于内存管理，速度快，不能当做数据库。Redis还有个固化数据的功能，VitualMemory，把一些不经常访问是会存在硬盘。可以哦诶之的，down掉会丢失数据snapshot可以保存到硬盘。AOF，数据辩护记录日志，很少用。Redis毕竟不是数据库，只能用来提升性能，不能作为数据的最终依据。

多线程模型：

　　.NET应用都是多线程模型，尤其是网站，可以更好的发挥硬件的能力，但是也有线冲突的问题和调度成本。

单线程模型：

　　Node.js是单线程，整个进程只有一个线程，线程就是执行流，性能低？实际上并非如此。一次网络请求操作----正则解析请求----加减乘除+数据库操作（发命令--等结果），读文件（发命令---等结果）+调用接口（发命令----等结果），单线程都是事件驱动，发起命令就做下一件事，这个线程是完全不做等待的，一直在计算。

　　多进程，多进程提供集群；单线程多进程的模式来提供集群服务。，B 查询还有没有--有---1更新

　　单线程最大的好处就是原子性操作，就是要么都成功，要么都失败，不会出现中间状态，Redis中的每个命令都是原子性的（因为单线程），不用考虑并发。

C#程序中，要使用Redis，首先要Nuget包安装一些程序集。下面是一些初始化的工作，写法一般都是固定的，我就折叠起来了。

 /// <summary>
 /// redis配置文件信息
 /// 也可以放到配置文件去
 /// </summary>
 public sealed class RedisConfigInfo
 {
     /// <summary>
     /// 可写的Redis链接地址
     /// format:ip1,ip2
     /// 
     /// 默认6379端口
     /// </summary>
     public string WriteServerList = "127.0.0.1:6379";
     /// <summary>
     /// 可读的Redis链接地址
     /// format:ip1,ip2
     /// </summary>
     public string ReadServerList = "127.0.0.1:6379";
     /// <summary>
     /// 最大写链接数
     /// </summary>
     public int MaxWritePoolSize = 60;
     /// <summary>
     /// 最大读链接数
     /// </summary>
     public int MaxReadPoolSize = 60;
     /// <summary>
     /// 本地缓存到期时间，单位:秒
     /// </summary>
     public int LocalCacheTime = 180;
     /// <summary>
     /// 自动重启
     /// </summary>
     public bool AutoStart = true;
     /// <summary>
     /// 是否记录日志,该设置仅用于排查redis运行时出现的问题,
     /// 如redis工作正常,请关闭该项
     /// </summary>
     public bool RecordeLog = false;
 }


 /// <summary>
 /// Redis管理中心
 /// </summary>
 public class RedisManager
 {
     /// <summary>
     /// redis配置文件信息
     /// </summary>
     private static RedisConfigInfo RedisConfigInfo = new RedisConfigInfo();

     /// <summary>
     /// Redis客户端池化管理
     /// </summary>
     private static PooledRedisClientManager prcManager;

     /// <summary>
     /// 静态构造方法，初始化链接池管理对象
     /// </summary>
     static RedisManager()
     {
         CreateManager();
     }

     /// <summary>
     /// 创建链接池管理对象
     /// </summary>
     private static void CreateManager()
     {
         string[] WriteServerConStr = RedisConfigInfo.WriteServerList.Split(',');
         string[] ReadServerConStr = RedisConfigInfo.ReadServerList.Split(',');
         prcManager = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr,
                          new RedisClientManagerConfig
                          {
                              MaxWritePoolSize = RedisConfigInfo.MaxWritePoolSize,
                              MaxReadPoolSize = RedisConfigInfo.MaxReadPoolSize,
                              AutoStart = RedisConfigInfo.AutoStart,
                          });
     }

     /// <summary>
     /// 客户端缓存操作对象
     /// </summary>
     public static IRedisClient GetClient()
     {
         return prcManager.GetClient();
     }
 }



 /// <summary>
 /// RedisBase类，是redis操作的基类，继承自IDisposable接口，主要用于释放内存
 /// </summary>
 public abstract class RedisBase : IDisposable
 {
     public IRedisClient iClient { get; private set; }
     /// <summary>
     /// 构造时完成链接的打开
     /// </summary>
     public RedisBase()
     {
         iClient = RedisManager.GetClient();
     }

     //public static IRedisClient iClient { get; private set; }
     //static RedisBase()
     //{
     //    iClient = RedisManager.GetClient();
     //}


     private bool _disposed = false;
     protected virtual void Dispose(bool disposing)
     {
         if (!this._disposed)
         {
             if (disposing)
             {
                 iClient.Dispose();
                 iClient = null;
             }
         }
         this._disposed = true;
     }
     public void Dispose()
     {
         Dispose(true);
         GC.SuppressFinalize(this);
     }

     public void Transcation()
     {
         using (IRedisTransaction irt = this.iClient.CreateTransaction())
         {
             try
             {
                 irt.QueueCommand(r => r.Set("key", 20));
                 irt.QueueCommand(r => r.Increment("key", 1));
                 irt.Commit(); // 提交事务
             }
             catch (Exception ex)
             {
                 irt.Rollback();
                 throw ex;
             }
         }
     }


     /// <summary>
     /// 清除全部数据 请小心
     /// </summary>
     public virtual void FlushAll()
     {
         iClient.FlushAll();
     }

     /// <summary>
     /// 保存数据DB文件到硬盘
     /// </summary>
     public void Save()
     {
         iClient.Save();//阻塞式save
     }

     /// <summary>
     /// 异步保存数据DB文件到硬盘
     /// </summary>
     public void SaveAsync()
     {
         iClient.SaveAsync();//异步save
     }
 }

Redis中的五大结构

1、String：

　　key-value，缓存，支持过期，value不超过512M。Redis单线程的特性，比如SetAll、AppendToValue、GetAndSetValue、IncrementValue、IncrementValueBy，这些命令，看上去是组合命令，实际上是具体的命令，是一个原则性的操作，不用考虑并发，不可能出现中间状态，可以应对一些并发情况。

　现在有个场景，就是超卖的问题，超卖，顾名思义，就是订单数超过商品。

　　数据库：秒杀的时候，10件商品，100个人想买，假定大家一瞬间都来了，A 查询还有没有--有---1更新；C 查询还有没有--有---1更新；可能会卖出12  12甚至20件商品；微服务也有超卖的问题，异步队列。Redis原子性操作--保证一个数值只出现一次--防止一个商品卖给多个人

　　Redis是单线程的，程序有怎么多线程操作Redis呢？打开多个链接，去提交任务，对程序而言，Redis是并发。所以用上了Redis，一方面保证绝对不会超卖，另一方面没有效率影响，数据库是可以为成功的人并发的，还有撤单的时候增加库存，可以继续秒杀，，限制秒杀的库存是放在redis，不是数据库，不会造成数据的不一致性，Redis能够拦截无效的请求，如果没有这一层，所有的请求压力都到数据库。

超卖的代码示例：

 /// <summary>
 /// key-value 键值对:value可以是序列化的数据
 /// </summary>
 public class RedisStringService : RedisBase
 {
     #region 赋值
     /// <summary>
     /// 设置key的value
     /// </summary>
     public bool Set<T>(string key, T value)
     {
         return base.iClient.Set<T>(key, value);
     }
     /// <summary>
     /// 设置key的value并设置过期时间
     /// </summary>
     public bool Set<T>(string key, T value, DateTime dt)
     {
         return base.iClient.Set<T>(key, value, dt);
     }
     /// <summary>
     /// 设置key的value并设置过期时间
     /// </summary>
     public bool Set<T>(string key, T value, TimeSpan sp)
     {
         return base.iClient.Set<T>(key, value, sp);
     }
     /// <summary>
     /// 设置多个key/value
     /// </summary>
     public void Set(Dictionary<string, string> dic)
     {
         base.iClient.SetAll(dic);
     }

     #endregion

     #region 追加
        /// <summary>
        /// 在原有key的value值之后追加value,没有就新增一项
        /// </summary>
        public long Append(string key, string value)
        {
            return base.iClient.AppendToValue(key, value);
        }
        #endregion

     #region 获取值
        /// <summary>
        /// 获取key的value值
        /// </summary>
        public string Get(string key)
        {
            return base.iClient.GetValue(key);
        }
        /// <summary>
        /// 获取多个key的value值
        /// </summary>
        public List<string> Get(List<string> keys)
        {
            return base.iClient.GetValues(keys);
        }
        /// <summary>
        /// 获取多个key的value值
        /// </summary>
        public List<T> Get<T>(List<string> keys)
        {
            return base.iClient.GetValues<T>(keys);
        }
        #endregion

     #region 获取旧值赋上新值
     /// <summary>
     /// 获取旧值赋上新值
     /// </summary>
     public string GetAndSetValue(string key, string value)
     {
         return base.iClient.GetAndSetValue(key, value);
     }
     #endregion

     #region 辅助方法
     /// <summary>
     /// 获取值的长度
     /// </summary>
     public long GetLength(string key)
     {
         return base.iClient.GetStringCount(key);
     }
     /// <summary>
     /// 自增1，返回自增后的值
     /// </summary>
     public long Incr(string key)
     {
         return base.iClient.IncrementValue(key);
     }
     /// <summary>
     /// 自增count，返回自增后的值
     /// </summary>
     public long IncrBy(string key, int count)
     {
         return base.iClient.IncrementValueBy(key, count);
     }
     /// <summary>
     /// 自减1，返回自减后的值
     /// </summary>
     public long Decr(string key)
     {
         return base.iClient.DecrementValue(key);
     }
     /// <summary>
     /// 自减count ，返回自减后的值
     /// </summary>
     /// <param name="key"></param>
     /// <param name="count"></param>
     /// <returns></returns>
     public long DecrBy(string key, int count)
     {
         return base.iClient.DecrementValueBy(key, count);
     }
     #endregion
 }

 public class OversellTest
 {
     private static bool IsGoOn = true;//秒杀活动是否结束
     public static void Show()
     {
         using (RedisStringService service = new RedisStringService())
         {
             service.Set<int>("Stock", 10);//是库存
         }

         for (int i = 0; i < 5000; i++)
         {
             int k = i;
             Task.Run(() =>//每个线程就是一个用户请求
             {
                 using (RedisStringService service = new RedisStringService())
                 {
                     if (IsGoOn)
                     {
                         long index = service.Decr("Stock");//-1并且返回  
                         if (index >= 0)
                         {
                             Console.WriteLine($"{k.ToString("000")}秒杀成功，秒杀商品索引为{index}");
                             //可以分队列，去数据库操作
                         }
                         else
                         {
                             if (IsGoOn)
                             {
                                 IsGoOn = false;
                             }
                             Console.WriteLine($"{k.ToString("000")}秒杀失败，秒杀商品索引为{index}");
                         }
                     }
                     else
                     {
                         Console.WriteLine($"{k.ToString("000")}秒杀停止......");
                     }
                 }
             });
         }
         Console.Read();
     }
 }


 public class OversellField
 {
     private static bool IsGoOn = true;//秒杀活动是否结束
     private static int Stock = 0;
     public static void Show()
     {
         Stock = 10;

         for (int i = 0; i < 5000; i++)
         {
             int k = i;
             Task.Run(() =>//每个线程就是一个用户请求
             {
                 if (IsGoOn)
                 {
                     long index = Stock;//-1并且返回 去数据库查一下当前的库存
                     Thread.Sleep(100);

                     if (index >= 1)
                     {
                         Stock = Stock - 1;//更新库存
                         Console.WriteLine($"{k.ToString("000")}秒杀成功，秒杀商品索引为{index}");
                         //可以分队列，去数据库操作
                     }
                     else
                     {
                         if (IsGoOn)
                         {
                             IsGoOn = false;
                         }
                         Console.WriteLine($"{k.ToString("000")}秒杀失败，秒杀商品索引为{index}");
                     }
                 }
                 else
                 {
                     Console.WriteLine($"{k.ToString("000")}秒杀停止......");
                 }
             });
         }
         Console.Read();
     }
 }

2、Hash

　　

 key-dictionary

　　1、节约空间（zipmap的紧密摆放的存储模式）

　　2、更新/访问方便（hashid+key）

　　3、Hash数据结构很想关系型数据库的一张表的一行数据。但是其实字段是可以随意定制的，没有严格约束。

缓存一个用户的信息，用String类型可以吗？也可以，因为String类型，key-value，先序列化，然后再反序列化，然后存储：

 using (RedisStringService service = new RedisStringService())
 {
     //service.Set<string>($"userinfo_{user.Id}", Newtonsoft.Json.JsonConvert.SerializeObject(user));
     service.Set<UserInfo>($"userinfo_{user.Id}", user);
     var userCacheList = service.Get<UserInfo>(new List<string>() { $"userinfo_{user.Id}" });
     var userCache = userCacheList.FirstOrDefault();
     //string sResult = service.Get($"userinfo_{user.Id}");
     //var userCache = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInfo>(sResult);
     userCache.Account = "Admin";
     service.Set<UserInfo>($"userinfo_{user.Id}", userCache);
 }

如果修改需求，就是查询---反序列化---修改---序列化---存储。这样真的太麻烦了。

现在有了Hash类型。

using (RedisHashService service = new RedisHashService())
{
    service.SetEntryInHash("student", "id", "bingle1");
    service.SetEntryInHash("student", "name", "bingle2");
    service.SetEntryInHash("student", "remark", "bingle3");

    var keys = service.GetHashKeys("student");
    var values = service.GetHashValues("student");
    var keyValues = service.GetAllEntriesFromHash("student");
    Console.WriteLine(service.GetValueFromHash("student", "id"));

    service.SetEntryInHashIfNotExists("student", "name", "bingle");
    service.SetEntryInHashIfNotExists("student", "description", "bingle");

    Console.WriteLine(service.GetValueFromHash("student", "name"));
    Console.WriteLine(service.GetValueFromHash("student", "description"));
    service.RemoveEntryFromHash("student", "description");
    Console.WriteLine(service.GetValueFromHash("student", "description"));
}

Hash---》Hashid---UserInfo　　

多个key，String类型的value，最小是512byte，即使只保存一个1，也要占用512byte的空间。而hash是一种zipmap存储，数据紧密排列，可以节约空间（配置zip两个属性，只要都满足就可以用zipmap存储）。

Hash的有点：

　　1、节约空间

　　2、更新方便

如果实体类型是带ID的，可以直接实体存储和读取。

 using (RedisHashService service = new RedisHashService())
 {
     service.FlushAll();
     //反射遍历做一下
     service.SetEntryInHash($"userinfo_{user.Id}", "Account", user.Account);
     service.SetEntryInHash($"userinfo_{user.Id}", "Name", user.Name);
     service.SetEntryInHash($"userinfo_{user.Id}", "Address", user.Address);
     service.SetEntryInHash($"userinfo_{user.Id}", "Email", user.Email);
     service.SetEntryInHash($"userinfo_{user.Id}", "Password", user.Password);
     service.SetEntryInHash($"userinfo_{user.Id}", "Account", "Admin");

     service.StoreAsHash<UserInfo>(user);//含ID才可以的
     var result = service.GetFromHash<UserInfo>(user.Id);

 }

3、Set

 using (RedisSetService service = new RedisSetService())
 {
     service.FlushAll();//清理全部数据

     service.Add("advanced", "111");
     service.Add("advanced", "112");
     service.Add("advanced", "114");
     service.Add("advanced", "114");
     service.Add("advanced", "115");
     service.Add("advanced", "115");
     service.Add("advanced", "113");

     var result = service.GetAllItemsFromSet("advanced");

     var random = service.GetRandomItemFromSet("advanced");//随机获取
     service.GetCount("advanced");//独立的ip数
     service.RemoveItemFromSet("advanced", "114");

     {
         service.Add("begin", "111");
         service.Add("begin", "112");
         service.Add("begin", "115");

         service.Add("end", "111");
         service.Add("end", "114");
         service.Add("end", "113");

         var result1 = service.GetIntersectFromSets("begin", "end");
         var result2 = service.GetDifferencesFromSet("begin", "end");
         var result3 = service.GetUnionFromSets("begin", "end");
         //共同好友   共同关注
     }
 }

 好友管理，共同好友，可能认识

去重：IP统计去重；添加好友申请；投票限制；点赞。

4、ZSet：是一个有序集合，去重

　　

using (RedisZSetService service = new RedisZSetService())
{
    service.FlushAll();//清理全部数据

    service.Add("advanced", "1");
    service.Add("advanced", "2");
    service.Add("advanced", "5");
    service.Add("advanced", "4");
    service.Add("advanced", "7");
    service.Add("advanced", "5");
    service.Add("advanced", "9");

    var result1 = service.GetAll("advanced");
    var result2 = service.GetAllDesc("advanced");

    service.AddItemToSortedSet("Sort", "bingle1", 123234);
    service.AddItemToSortedSet("Sort", "bingle2", 123);
    service.AddItemToSortedSet("Sort", "bingle3", 45);
    service.AddItemToSortedSet("Sort", "bingle4", 7567);
    service.AddItemToSortedSet("Sort", "bingle5", 9879);
    service.AddRangeToSortedSet("Sort", new List<string>() { "123", "花生", "加菲猫" }, 3232);
    var result3 = service.GetAllWithScoresFromSortedSet("Sort");

    //交叉并
}

 最后一个参数，是自己设定的，设定value的分数的。

 实时排行榜：刷个礼物。

维度很多，平台/房间/主播/日/周/年/月

A对B刷个礼物，影响很多。

没Redis之前，刷个礼物值记录流水，不影响排行，凌晨24点跑任务更新。

实时排行榜，Redis-IncrementItemInSortedSet，刷礼物增加Redis分数，就可以试试获取最新的排行，多个维度就是多个ZSet，刷礼物的时候保存数据库并更新Redis。

5、List

　　

生产者消费者：

using (RedisListService service = new RedisListService())
{
    service.Add("test", "这是一个学生Add1");
    service.Add("test", "这是一个学生Add2");
    service.Add("test", "这是一个学生Add3");

    service.LPush("test", "这是一个学生LPush1");
    service.LPush("test", "这是一个学生LPush2");
    service.LPush("test", "这是一个学生LPush3");
    service.LPush("test", "这是一个学生LPush4");
    service.LPush("test", "这是一个学生LPush5");
    service.LPush("test", "这是一个学生LPush6");

    service.RPush("test", "这是一个学生RPush1");
    service.RPush("test", "这是一个学生RPush2");
    service.RPush("test", "这是一个学生RPush3");
    service.RPush("test", "这是一个学生RPush4");
    service.RPush("test", "这是一个学生RPush5");
    service.RPush("test", "这是一个学生RPush6");

    List<string> stringList = new List<string>();
    for (int i = 0; i < 10; i++)
    {
        stringList.Add(string.Format($"放入任务{i}"));
    }
    service.Add("task", stringList);

    Console.WriteLine(service.Count("test"));
    Console.WriteLine(service.Count("task"));
    var list = service.Get("test");
    list = service.Get("task", 2, 4);

    Action act = new Action(() =>
    {
        while (true)
        {
            Console.WriteLine("************请输入数据**************");
            string testTask = Console.ReadLine();
            service.LPush("test", testTask);
        }
    });
    act.EndInvoke(act.BeginInvoke(null, null));
}

生产者消费者（队列）一个数据，只能被一个对象消费，一个程序写入，一个程序即时读取消费，还可以多个程序读取消费，按照时间顺序，数据失败了还可以放回去下次重试，这种东西在项目中有什么价值呢？和那些MQ差不多，就是队列。

异步队列：

　　优点：

　　　　1、可以控制并发数量

　　　　2、以前要求立马处理完，现在可以在一个时段完成

　　　　3、失败还能重试

　　　　4、流量削峰，降低高峰期的压力

　　　　5、高可用

　　　　6、可扩展

　　缺点：

　　　　1、不能理解处理

　　　　2、事务的一致性问题。

发布订阅，发布一个数据，全部的订阅者都能收到。观察者，一个数据源，多个接受者，只要订阅了就可以收到的，能被多个数据源共享。观察者模式：微信订阅号---群聊天----数据同步

MSMQ---RabbitMQ---ZeroMQ----RocketMQ---RedisList

分布式缓存，多个服务器都可以访问到，多个生产者，多个消费者，任何产品只被消费一次。

 using (RedisListService service = new RedisListService())
 {

     service.Add("test", "这是一个学生Add1");
     service.Add("test", "这是一个学生Add2");
     service.Add("test", "这是一个学生Add3");

     service.LPush("test", "这是一个学生LPush1");
     service.LPush("test", "这是一个学生LPush2");
     service.LPush("test", "这是一个学生LPush3");
     service.LPush("test", "这是一个学生LPush4");
     service.LPush("test", "这是一个学生LPush5");
     service.LPush("test", "这是一个学生LPush6");

     service.RPush("test", "这是一个学生RPush1");
     service.RPush("test", "这是一个学生RPush2");
     service.RPush("test", "这是一个学生RPush3");
     service.RPush("test", "这是一个学生RPush4");
     service.RPush("test", "这是一个学生RPush5");
     service.RPush("test", "这是一个学生RPush6");

     List<string> stringList = new List<string>();
     for (int i = 0; i < 10; i++)
     {
         stringList.Add(string.Format($"放入任务{i}"));
     }
     service.Add("task", stringList);

     Console.WriteLine(service.Count("test"));
     Console.WriteLine(service.Count("task"));
     var list = service.Get("test");
     list = service.Get("task", 2, 4);

     //Action act = new Action(() =>
     //{
     //    while (true)
     //    {
     //        Console.WriteLine("************请输入数据**************");
     //        string testTask = Console.ReadLine();
     //        service.LPush("test", testTask);
     //        Console.ReadLine();
     //    }
     //});
     //act.EndInvoke(act.BeginInvoke(null, null));

     while (true)
     {
         Console.WriteLine("************请输入数据**************");
         string testTask = Console.ReadLine();
         service.LPush("test", testTask);
     }

 }

 public class ServiceStackProcessor
 {
     public static void Show()
     {
         string path = AppDomain.CurrentDomain.BaseDirectory;
         string tag = path.Split('/', '\').Last(s => !string.IsNullOrEmpty(s));
         Console.WriteLine($"这里是 {tag} 启动了。。");
         using (RedisListService service = new RedisListService())
         {
             Action act = new Action(() =>
             {
                 while (true)
                 {
                     var result = service.BlockingPopItemFromLists(new string[] { "test", "task" }, TimeSpan.FromHours(3));
                     Thread.Sleep(100);
                     Console.WriteLine($"这里是 {tag} 队列获取的消息 {result.Id} {result.Item}");
                 }
             });
             act.EndInvoke(act.BeginInvoke(null, null));
         }
     }

 }

ask项目，问答，一天的问题都是几万，表里面是几千万数据，首页要战士最新的问题，Ajax动态定时获取刷新，还有前20也是很多人访问的。

每次写入数据库的时候，把ID_标题写到RedisList，后面搞个TrimList，只要最近200个，用户刷新页面的时候就不需要去数据库了，直接Redis。

还有一种就是水平分表，第一次的时候不管分页，只拿数据，存数据的时候可以保存id+表全名。

主要解决数据量大，变化的数据分页问题。二八原则，80%的访问集中在20%的数据，List里面只用保存大概的量就够了。