FROM redis:4

 MAINTAINER dabolang

 EXPOSE 26379
 ADD sentinel.conf /etc/redis/sentinel.conf
 RUN chown redis:redis /etc/redis/sentinel.conf
 ENV SENTINEL_QUORUM 2
 ENV SENTINEL_DOWN_AFTER 30000
 ENV SENTINEL_FAILOVER 180000

 COPY sentinel-entrypoint.sh /usr/local/bin/
 RUN chmod +x /usr/local/bin/sentinel-entrypoint.sh

 ENTRYPOINT ["sentinel-entrypoint.sh"]
 

 # Example sentinel.conf can be downloaded from http://download.redis.io/redis-stable/sentinel.conf
 # $SENTINEL_QUORUM 2   判断Sentinel失效的数量，超过failover才会执行
 # $SENTINEL_DOWN_AFTER  5000 指定了Sentinel认为Redis实例已经失效所需的毫秒数
 # $SENTINEL_FAILOVER  5000  如果在该时间（ms）内未能完成failover操作，则认为该failover失败

 #=======================================================================================
 # 监听端口号
 #=======================================================================================
 port 26379

 #=======================================================================================
 # Sentinel服务运行时使用的临时文件夹
 #=======================================================================================
 dir /tmp

 #=======================================================================================
 # Sentinel去监视一个名为mymaster的主redis实例，
 # 这个主实例的为Docker,redis-master容器(也可以是IP)，端口号为6379，
 # 主实例判断为失效至少需要$SENTINEL_QUORUM个Sentinel进程的同意，只要同意Sentinel的数量不达标，自动failover就不会执行
 # sentinel monitor mymaster redis-master 6379 2
 #=======================================================================================
 sentinel monitor mymaster redis-master 6379 $SENTINEL_QUORUM

 #=======================================================================================
 # 指定了Sentinel认为Redis实例已经失效所需的毫秒数$SENTINEL_DOWN_AFTER,默认是30000毫秒。
 # 当实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。
 # 只有一个Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行
 # sentinel down-after-milliseconds mymaster 30000
 #=======================================================================================
 sentinel down-after-milliseconds mymaster $SENTINEL_DOWN_AFTER

 #=======================================================================================
 # 指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，
 # 在从Redis实例较多的情况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长
 #=======================================================================================
 sentinel parallel-syncs mymaster 1

 #=======================================================================================
 # 如果在该时间（ms）内未能完成failover操作，则认为该failover失败
 # sentinel failover-timeout mymaster 180000
 #=======================================================================================
 sentinel failover-timeout mymaster $SENTINEL_FAILOVER

 #指定sentinel检测到该监控的redis实例指向的实例异常时，调用的报警脚本。该配置项可选，但是很常用
 # Example:
 #
 # sentinel notification-script mymaster /var/redis/notify.sh

 using System;
 using System.Text;
 using Newtonsoft.Json;
 using Nop.Core.Configuration;
 using Nop.Core.Infrastructure;
 using StackExchange.Redis;
 using System.Linq;

 namespace Nop.Core.Caching
 {
     /// <summary>
     /// 命名空间：Nop.Core.Caching
     /// 名    称：RedisMSCacheManager
     /// 功    能：
     /// 详    细：
     /// 版    本：1.0.0.0
     /// 文件名称：RedisMSCacheManager.cs
     /// 创建时间：2017-08-29 03:15
     /// 修改时间：2017-08-30 05:28
     /// 作    者：大波浪
     /// 联系方式：http://www.cnblogs.com/yaoshangjin
     /// 说    明：
     /// </summary>
     public partial class RedisMSCacheManager : ICacheManager
     {
         #region Fields
         private readonly IRedisConnectionWrapper _connectionWrapper;
         private readonly IDatabase _db;
         private readonly ICacheManager _perRequestCacheManager;

         #endregion

         #region Ctor

         public RedisMSCacheManager(NopConfig config, IRedisConnectionWrapper connectionWrapper)
         {
             if (String.IsNullOrEmpty(config.RedisCachingConnectionString))
                 throw new Exception("Redis connection string is empty");

             // ConnectionMultiplexer.Connect should only be called once and shared between callers
             this._connectionWrapper = connectionWrapper;

             this._db = _connectionWrapper.GetDatabase();
             this._perRequestCacheManager = EngineContext.Current.Resolve<ICacheManager>();
         }

         #endregion

         #region Utilities

         protected virtual byte[] Serialize(object item)
         {
             var jsonString = JsonConvert.SerializeObject(item);
             return Encoding.UTF8.GetBytes(jsonString);
         }
         protected virtual T Deserialize<T>(byte[] serializedObject)
         {
             if (serializedObject == null)
                 return default(T);

             var jsonString = Encoding.UTF8.GetString(serializedObject);
             return JsonConvert.DeserializeObject<T>(jsonString);
         }

         #endregion

         #region Methods

         /// <summary>
         /// Gets or sets the value associated with the specified key.
         /// </summary>
         /// <typeparam name="T">Type</typeparam>
         /// <param name="key">The key of the value to get.</param>
         /// <returns>The value associated with the specified key.</returns>
         public virtual T Get<T>(string key)
         {
             //little performance workaround here:
             //we use "PerRequestCacheManager" to cache a loaded object in memory for the current HTTP request.
             //this way we won't connect to Redis server 500 times per HTTP request (e.g. each time to load a locale or setting)
             if (_perRequestCacheManager.IsSet(key))
                 return _perRequestCacheManager.Get<T>(key);

             var rValue = _db.StringGet(key);
             if (!rValue.HasValue)
                 return default(T);
             var result = Deserialize<T>(rValue);

             _perRequestCacheManager.Set(key, result, 0);
             return result;
         }

         /// <summary>
         /// Adds the specified key and object to the cache.
         /// </summary>
         /// <param name="key">key</param>
         /// <param name="data">Data</param>
         /// <param name="cacheTime">Cache time</param>
         public virtual void Set(string key, object data, int cacheTime)
         {
             if (data == null)
                 return;

             var entryBytes = Serialize(data);
             var expiresIn = TimeSpan.FromMinutes(cacheTime);
             _db.StringSet(key, entryBytes, expiresIn);
         }

         /// <summary>
         /// Gets a value indicating whether the value associated with the specified key is cached
         /// </summary>
         /// <param name="key">key</param>
         /// <returns>Result</returns>
         public virtual bool IsSet(string key)
         {
             //little performance workaround here:
             //we use "PerRequestCacheManager" to cache a loaded object in memory for the current HTTP request.
             //this way we won't connect to Redis server 500 times per HTTP request (e.g. each time to load a locale or setting)
             if (_perRequestCacheManager.IsSet(key))
                 return true;

             return _db.KeyExists(key);
         }

         /// <summary>
         /// Removes the value with the specified key from the cache
         /// </summary>
         /// <param name="key">/key</param>
         public virtual void Remove(string key)
         {
             _db.KeyDelete(key);
             _perRequestCacheManager.Remove(key);
         }

         /// <summary>
         /// Removes items by pattern
         /// </summary>
         /// <param name="pattern">pattern</param>
         public virtual void RemoveByPattern(string pattern)
         {
             foreach (var ep in _connectionWrapper.GetEndPoints())
             {
                 var server = _connectionWrapper.GetServer(ep);
                 if (server.IsConnected == false || server.IsSlave == true) continue;
                 var keys = server.Keys(database: _db.Database, pattern: "*" + pattern + "*");
                 foreach (var key in keys)
                     Remove(key);
             }
         }

         /// <summary>
         /// Clear all cache data
         /// </summary>
         public virtual void Clear()
         {
             foreach (var ep in _connectionWrapper.GetEndPoints())
             {
                 var server = _connectionWrapper.GetServer(ep);
                 if (server.IsConnected == false|| server.IsSlave==true) continue;
                 //we can use the code below (commented)
                 //but it requires administration permission - ",allowAdmin=true"
                 //server.FlushDatabase();

                 //that's why we simply interate through all elements now
                 var keys = server.Keys(database: _db.Database);
                 foreach (var key in keys)
                     Remove(key);
             }
         }

         /// <summary>
         /// Dispose
         /// </summary>
         public virtual void Dispose()
         {
             //if (_connectionWrapper != null)
             //    _connectionWrapper.Dispose();
         }

         #endregion

     }
 }
 

 using System;
 using System.Linq;
 using System.Net;
 using Nop.Core.Configuration;
 using RedLock;
 using StackExchange.Redis;

 namespace Nop.Core.Caching
 {
     /// <summary>
     /// Redis connection wrapper implementation
     /// </summary>
     public class RedisConnectionWrapper : IRedisConnectionWrapper
     {
         #region Fields

         private readonly NopConfig _config;
         private readonly Lazy<string> _connectionString;

         private volatile ConnectionMultiplexer _connection;
         private volatile RedisLockFactory _redisLockFactory;
         private readonly object _lock = new object();

         #endregion

         #region Ctor

         public RedisConnectionWrapper(NopConfig config)
         {
             this._config = config;
             this._connectionString = new Lazy<string>(GetConnectionString);
             this._redisLockFactory = CreateRedisLockFactory();
         }

         #endregion

         #region Utilities

         /// <summary>
         /// Get connection string to Redis cache from configuration
         /// </summary>
         /// <returns></returns>
         protected string GetConnectionString()
         {
             return _config.RedisCachingConnectionString;
         }

         /// <summary>
         /// Get connection to Redis servers
         /// </summary>
         /// <returns></returns>
         protected ConnectionMultiplexer GetConnection()
         {
             if (_connection != null && _connection.IsConnected) return _connection;

             lock (_lock)
             {
                 if (_connection != null && _connection.IsConnected) return _connection;

                 if (_connection != null)
                 {
                     //Connection disconnected. Disposing connection...
                     _connection.Dispose();
                 }

                 //Creating new instance of Redis Connection
                 _connection = ConnectionMultiplexer.Connect(_connectionString.Value);
             }

             return _connection;
         }

         /// <summary>
         /// Create instance of RedisLockFactory
         /// </summary>
         /// <returns>RedisLockFactory</returns>
         protected RedisLockFactory CreateRedisLockFactory()
         {
             //get password and value whether to use ssl from connection string
             var password = string.Empty;
             var useSsl = false;
             foreach (var option in GetConnectionString().Split(',').Where(option => option.Contains('=')))
             {
                 switch (option.Substring(0, option.IndexOf('=')).Trim().ToLowerInvariant())
                 {
                     case "password":
                         password = option.Substring(option.IndexOf('=') + 1).Trim();
                         break;
                     case "ssl":
                         bool.TryParse(option.Substring(option.IndexOf('=') + 1).Trim(), out useSsl);
                         break;
                 }
             }

             //create RedisLockFactory for using Redlock distributed lock algorithm
             return new RedisLockFactory(GetEndPoints().Select(endPoint => new RedisLockEndPoint
             {
                 EndPoint = endPoint,
                 Password = password,
                 Ssl = useSsl
             }));
         }

         #endregion

         #region Methods

         /// <summary>
         /// Obtain an interactive connection to a database inside redis
         /// </summary>
         /// <param name="db">Database number; pass null to use the default value</param>
         /// <returns>Redis cache database</returns>
         public IDatabase GetDatabase(int? db = null)
         {
             return GetConnection().GetDatabase(db ?? -1); //_settings.DefaultDb);
         }

         /// <summary>
         /// Obtain a configuration API for an individual server
         /// </summary>
         /// <param name="endPoint">The network endpoint</param>
         /// <returns>Redis server</returns>
         public IServer GetServer(EndPoint endPoint)
         {
             return GetConnection().GetServer(endPoint);
         }

         /// <summary>
         /// Gets all endpoints defined on the server
         /// </summary>
         /// <returns>Array of endpoints</returns>
         public EndPoint[] GetEndPoints()
         {
             return GetConnection().GetEndPoints();
         }

         /// <summary>
         /// Delete all the keys of the database
         /// </summary>
         /// <param name="db">Database number; pass null to use the default value<</param>
         public void FlushDatabase(int? db = null)
         {
             var endPoints = GetEndPoints();

             foreach (var endPoint in endPoints)
             {
                 GetServer(endPoint).FlushDatabase(db ?? -1); //_settings.DefaultDb);
             }
         }

         /// <summary>
         /// Perform some action with Redis distributed lock
         /// </summary>
         /// <param name="resource">The thing we are locking on</param>
         /// <param name="expirationTime">The time after which the lock will automatically be expired by Redis</param>
         /// <param name="action">Action to be performed with locking</param>
         /// <returns>True if lock was acquired and action was performed; otherwise false</returns>
         public bool PerformActionWithLock(string resource, TimeSpan expirationTime, Action action)
         {
             //use RedLock library
             using (var redisLock = _redisLockFactory.Create(resource, expirationTime))
             {
                 //ensure that lock is acquired
                 if (!redisLock.IsAcquired)
                     return false;

                 //perform action
                 action();
                 return true;
             }
         }

         /// <summary>
         /// Release all resources associated with this object
         /// </summary>
         public void Dispose()
         {
             //dispose ConnectionMultiplexer
             if (_connection != null)
                 _connection.Dispose();

             //dispose RedisLockFactory
             if (_redisLockFactory != null)
                 _redisLockFactory.Dispose();
         }

         #endregion
     }
 }
 

 using System;
 using System.Configuration;
 using System.Net.Sockets;
 using System.Threading;
 using System.Threading.Tasks;
 using Nop.Core.Caching;
 using Nop.Core.Configuration;
 using Nop.Tests;
 using NUnit.Framework;
 using StackExchange.Redis;

 namespace Nop.Core.Tests.Caching
 {
     [TestFixture]
     public class RedisMSCacheManagerTests
     {
         private NopConfig _nopConfig;
         private RedisMSCacheManager cacheManager;
         private RedisMSConnectionWrapper _redisMSConnectionWrapper;
         [SetUp]
         public void SetUp()
         {
             _nopConfig = ConfigurationManager.GetSection("NopConfig") as NopConfig;
             cacheManager = new RedisMSCacheManager(_nopConfig, new RedisMSConnectionWrapper(_nopConfig));
             _redisMSConnectionWrapper = new RedisMSConnectionWrapper(_nopConfig);
         }

         [Test]
         public void Set_Cache_Test()
         {
             int i = 0;
             while (i < 150)
             {
                 var key = DateTime.UtcNow.ToString("hh-mm-ss");
                 try
                 {
                     cacheManager.Set(key, DateTime.UtcNow.ToString(), 600000);
                     var ok = "true";
                     Console.WriteLine(key + ":" + ok);
                 }
                 catch (Exception)
                 {
                     Console.WriteLine("出错了:" + key);
                 }

                 Thread.Sleep(500);
                 i++;
             }
             var a = 2;
         }
         [Test]
         public void Can_set_and_get_object_from_cache()
         {
             cacheManager.Set("some_key_1", 3, int.MaxValue);

             cacheManager.Get<int>("some_key_1").ShouldEqual(3);
         }
         [Test]
         public void Can_validate_whetherobject_is_cached()
         {
             cacheManager.Set("some_key_1", 3, int.MaxValue);
             cacheManager.Set("some_key_2", 4, int.MaxValue);

             cacheManager.IsSet("some_key_1").ShouldEqual(true);
             cacheManager.IsSet("some_key_3").ShouldEqual(false);
         }

         [Test]
         public void Can_clear_cache()
         {
             cacheManager.Set("some_key_1", 3, int.MaxValue);

             cacheManager.Clear();

             cacheManager.IsSet("some_key_1").ShouldEqual(false);
         }
         [Test]
         public void TestLock()
         {

             RedisKey _lockKey = "lock_key";
             var  _lockDuration = TimeSpan.FromSeconds(30);
             var mainTask=new Task(()=>_redisMSConnectionWrapper.PerformActionWithLock(_lockKey, _lockDuration, () =>
             {
                 Console.WriteLine("1.执行锁内任务-开始");
                 Thread.Sleep(10000);
                 Console.WriteLine("1.执行锁内任务-结束");
             }));
             mainTask.Start();
             Thread.Sleep(1000);
             var subOk = true;
             while (subOk)
             {
                 _redisMSConnectionWrapper.PerformActionWithLock(_lockKey, _lockDuration, () =>
                 {
                     Console.WriteLine("2.执行锁内任务-开始");
                     Console.WriteLine("2.执行锁内任务-结束");
                     subOk = false;
                 });
                 Thread.Sleep(1000);
             }
             Console.WriteLine("结束");
         }

     }
 }
 

 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <configSections>
     <section name="NopConfig" type="Nop.Core.Configuration.NopConfig, Nop.Core" requirePermission="false" />
   </configSections>
   <NopConfig>
     <RedisCaching Enabled="true" ConnectionString="localhost:7010,localhost:7011" />
   </NopConfig>
 <startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.1" /></startup>
   <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="Autofac" publicKeyToken="17863af14b0044da" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-4.4.0.0" newVersion="4.4.0.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-5.2.3.0" newVersion="5.2.3.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="StackExchange.Redis.StrongName" publicKeyToken="c219ff1ca8c2ce46" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-1.2.1.0" newVersion="1.2.1.0" />
       </dependentAssembly>
     </assemblyBinding>
   </runtime>
 </configuration>