Service-stack.redis 使用PooledRedisClientManager 速度慢的原因之一

現在越來越多的開發者使用service-stack.redis 來進行redis的訪問，但是獲取redisclient的方式有多種方式，其中有一種從緩沖池獲取client的方式很是得到大家的認可。

 List<string> listWrite = new List<string>() { "6380@192.168.8.245:6380" };
            List<string> readHosts = new List<string>() { "192.168.8.245:6381", "192.168.8.245:6382" };
            PooledRedisClientManager clientManager = PoolManagerFactory.CreateManager(listWrite.ToArray(), readHosts.ToArray());
            ///可以在緩存管理器中加入密碼驗證  因為沒有對應的密碼字段顯示
          ///通過getClient獲取一個client 連接
            using (IRedisClient redisClient = clientManager.GetClient())
            {
                IRedisTypedClient<Phone> phones = redisClient.As<Phone>();
                
                Phone phoneFive = phones.GetValue("5");
                if (phoneFive == null)
                {
                    phoneFive = new Phone()
                    {
                        ID = 5,
                        Manufacturer = "Nokia",
                        Model = "guozhiqi",
                        Owner = new Person()
                        {

                            ID = 1,
                            Name = "袁金州",
                            Surname = "Old"
                        }
                    };
                    phones.SetEntry(phoneFive.ID.ToString(), phoneFive);
                }
                Console.WriteLine("OwnerID" + phones.GetValue("5").Owner.Name);
            }

請注意上面代碼的第五行，using (IRedisClient redisClient = clientManager.GetClient()){}

通過clientManager.getClient方法來獲取一個連接，我們在ado.net中也是采用這種方式，而且性能很高。我們認為這種方式的工作方式肯定是首先從緩沖池中獲取一條連接，然后執行using里面的代碼，最后dispose。但是有時候這種方式在稍微訪問量大的時候性能很低，什么原因呢？

 /// <summary>
        /// Returns a Read/Write client (The default) using the hosts defined in ReadWriteHosts
        /// 返回可以讀寫的 客戶端連接   默認的  使用定義在readWriteHosts中的服務器地址
        /// </summary>
        /// <returns></returns>
        public IRedisClient GetClient()
        {
            lock (writeClients)
            {
                AssertValidReadWritePool();

                RedisClient inActiveClient;
                while ((inActiveClient = GetInActiveWriteClient()) == null)
                {
                    if (PoolTimeout.HasValue)
                    {
                        // wait for a connection, cry out if made to wait too long
                        if (!Monitor.Wait(writeClients, PoolTimeout.Value))
                            throw new TimeoutException(PoolTimeoutError);
                    }
                    else
                        Monitor.Wait(writeClients, RecheckPoolAfterMs);
                }

                WritePoolIndex++;
                inActiveClient.Active = true;

                if (this.ConnectTimeout != null)
                {
                    inActiveClient.ConnectTimeout = this.ConnectTimeout.Value;
                }

                if (this.SocketSendTimeout.HasValue)
                {
                    inActiveClient.SendTimeout = this.SocketSendTimeout.Value;
                }
                if (this.SocketReceiveTimeout.HasValue)
                {
                    inActiveClient.ReceiveTimeout = this.SocketReceiveTimeout.Value;
                }
                if (this.IdleTimeOutSecs.HasValue)
                {
                    inActiveClient.IdleTimeOutSecs = this.IdleTimeOutSecs.Value;
                }

                inActiveClient.NamespacePrefix = NamespacePrefix;

                //Reset database to default if changed
                if (inActiveClient.Db != Db)
                {
                    inActiveClient.ChangeDb(Db);
                }

                return inActiveClient;
            }
        }

這是service-stack.redis中getClient的實現，但是我們發現了一個問題就是，他只從主 redis中獲取連接，不可能返回slave 的readonly 連接。

如果緩存設置為5，那么如果同時500個請求，還是會有性能影響的，因為完全忽略了slave的讀的功能。

如果要寫，我們可以調用clientManager.GetClient() 來獲取writeHosts的redis實例。

如果要讀，我們可以調用clientManager.GetReadOnlyClient()來獲取僅僅是readonlyHost的redis實例。

如果你嫌麻煩，那么完全可以使用clientManager.GetCacheClient() 來獲取一個連接，他會在寫的時候調用GetClient獲取連接，讀的時候調用GetReadOnlyClient獲取連接，這樣可以做到讀寫分離，從而利用redis的主從復制功能。