Question

我最近切换了一个MVC应用程序，它从v3.9.67 ServiceStack.Redis客户端向最新的StackExchange.Redis客户端（v1.0.450）提供数据馈送和动态生成的图像（6k rpm吞吐量），并且我看到了一些较慢的性能和一些新的例外。

我们的Redis实例是S4级别（13GB），CPU显示相当恒定的45％左右，网络带宽显得相当低。我不完全确定如何解释Azure门户中的获取/设置图，但它向我们显示了大约1M获取和100k集（看起来这可能是以5分钟为增量）。

客户端库交换机很简单，我们仍在使用v3.9 ServiceStack JSON序列化程序，因此客户端库是唯一更改的部分。

我们使用New Relic进行的外部监控清楚地表明，我们的平均响应时间从ServiceStack和StackExchange库之间的大约200ms增加到大约280ms（StackExchange更慢），没有其他变化。

我们在以下行中记录了许多例外情况：

执行GET馈送通道的超时：ag177kxj_egeo-_nek0cew，inst：12，mgr：无效，队列：30，qu = 0，qs = 30，qc = 0，wr = 0/0，in = 0/0 < / p>

我理解这意味着队列中有许多命令已经发送但Redis没有响应，并且这可能是由超出超时的长时间运行命令引起的。这些错误出现在我们的一个数据服务后面的sql数据库被备份的时期，所以也许这就是原因？在扩展该数据库以减少负载后，我们还没有看到更多此错误，但是数据库查询应该在.Net中发生，我不知道这将如何阻止redis命令或连接

我们今天早上还在短时间内（几分钟）记录了大量错误，其中包含以下消息：

没有可用于此操作的连接：SETEX feed-channels：vleggqikrugmxeprwhwc2a：last-retry

我们习惯了与ServiceStack库的瞬时连接错误，这些异常消息通常是这样的：

无法连接：sPort：63980

我认为SE.Redis应该在后台为我重试连接和命令。我是否还需要通过SE.Redis在我自己的重试政策中打包我们的电话？也许不同的超时值更合适（虽然我不确定使用什么值）？

我们的redis连接字符串设置了以下参数：abortConnect=false,syncTimeout=2000,ssl=true。我们使用ConnectionMultiplexer的单例实例和IDatabase的瞬态实例。

我们的Redis绝大部分都使用了Cache类，并且实现的重要部分在下面，以防我们做一些愚蠢的事情导致我们出现问题。

我们的密钥通常是10-30个字符串。值主要是标量或相当小的序列化对象集（通常为百字节到几KB），但我们也将jpg图像存储在缓存中，因此大部分数据从几百KB到几MB。

也许我应该为小型和大型值使用不同的多路复用器，可能需要更长的超时时间才能获得更大的值？或者在一个停止的情况下偶合/少数多路复用器？

public class Cache : ICache
{
    private readonly IDatabase _redis;

    public Cache(IDatabase redis)
    {
        _redis = redis;
    }

    // storing this placeholder value allows us to distinguish between a stored null and a non-existent key
    // while only making a single call to redis. see Exists method.
    static readonly string NULL_PLACEHOLDER = "$NULL_VALUE$";

    // this is a dictionary of https://github.com/StephenCleary/AsyncEx/wiki/AsyncLock
    private static readonly ILockCache _locks = new LockCache();

    public T GetOrSet<T>(string key, TimeSpan cacheDuration, Func<T> refresh) {
        T val;
        if (!Exists(key, out val)) {
            using (_locks[key].Lock()) {
                if (!Exists(key, out val)) {
                    val = refresh();
                    Set(key, val, cacheDuration);
                }
            }
        }
        return val;
    }

    private bool Exists<T>(string key, out T value) {
        value = default(T);
        var redisValue = _redis.StringGet(key);

        if (redisValue.IsNull)
            return false;

        if (redisValue == NULL_PLACEHOLDER)
            return true;

        value = typeof(T) == typeof(byte[])
            ? (T)(object)(byte[])redisValue
            : JsonSerializer.DeserializeFromString<T>(redisValue);

        return true;
    }

    public void Set<T>(string key, T value, TimeSpan cacheDuration)
    {
        if (value.IsDefaultForType())
            _redis.StringSet(key, NULL_PLACEHOLDER, cacheDuration);
        else if (typeof (T) == typeof (byte[]))
            _redis.StringSet(key, (byte[])(object)value, cacheDuration);
        else
            _redis.StringSet(key, JsonSerializer.SerializeToString(value), cacheDuration);
    }


    public async Task<T> GetOrSetAsync<T>(string key, Func<T, TimeSpan> getSoftExpire, TimeSpan additionalHardExpire, TimeSpan retryInterval, Func<Task<T>> refreshAsync) {
        var softExpireKey = key + ":soft-expire";
        var lastRetryKey = key + ":last-retry";

        T val;
        if (ShouldReturnNow(key, softExpireKey, lastRetryKey, retryInterval, out val)) 
            return val;

        using (await _locks[key].LockAsync()) {
            if (ShouldReturnNow(key, softExpireKey, lastRetryKey, retryInterval, out val))
                return val;

            Set(lastRetryKey, DateTime.UtcNow, additionalHardExpire);

            try {
                var newVal = await refreshAsync();
                var softExpire = getSoftExpire(newVal);
                var hardExpire = softExpire + additionalHardExpire;

                if (softExpire > TimeSpan.Zero) {
                    Set(key, newVal, hardExpire);
                    Set(softExpireKey, DateTime.UtcNow + softExpire, hardExpire);
                }
                val = newVal;
            }
            catch (Exception ex) {
                if (val == null)
                    throw;
            }
        }

        return val;
    }

    private bool ShouldReturnNow<T>(string valKey, string softExpireKey, string lastRetryKey, TimeSpan retryInterval, out T val) {
        if (!Exists(valKey, out val))
            return false;

        var softExpireDate = Get<DateTime?>(softExpireKey);
        if (softExpireDate == null)
            return true;

        // value is in the cache and not yet soft-expired
        if (softExpireDate.Value >= DateTime.UtcNow)
            return true;

        var lastRetryDate = Get<DateTime?>(lastRetryKey);

        // value is in the cache, it has soft-expired, but it's too soon to try again
        if (lastRetryDate != null && DateTime.UtcNow - lastRetryDate.Value < retryInterval) {
            return true;
        }

        return false;
    }
}

Answer 1

一些建议。 - 您可以为不同类型的键/值使用具有不同超时值的不同多路复用器 http://azure.microsoft.com/en-us/documentation/articles/cache-faq/ - 确保您没有在客户端和服务器上绑定网络。如果您在服务器上，则转移到具有更多带宽的更高SKU 请阅读这篇文章了解更多详情 http://azure.microsoft.com/blog/2015/02/10/investigating-timeout-exceptions-in-stackexchange-redis-for-azure-redis-cache/

Azure上的StackExchange.Redis抛出超时执行get和无连接可用异常

1 个答案: