3

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

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

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

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

我们记录了一些异常情况，其中包含以下消息：

执行 GET feed-channels 超时：ag177kxj_egeo-_nek0cew，inst：12，mgr：非活动，队列：30，qu=0，qs=30，qc=0，wr=0/0，in=0/0

我理解这意味着队列中有许多命令已发送，但 Redis 没有响应，这可能是由于长时间运行的命令超过了超时时间造成的。当我们的一个数据服务背后的 sql 数据库正在备份时，这些错误出现了一段时间，所以也许这就是原因？在扩展该数据库以减少负载后，我们还没有看到更多此类错误，但 DB 查询应该发生在 .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 类，实现的重要部分如下，以防我们做一些愚蠢的事情导致我们出现问题。

我们的key一般是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;
    }
}
4

1 回答 1

3

一些建议。- 对于不同类型的键/值，您可以使用具有不同超时值的不同多路复用器 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/

于 2015-05-22T19:22:54.550 回答