MemoryCache Thread An toàn, Khóa có cần thiết không?

Đối với người mới bắt đầu, hãy để tôi chỉ cần ném nó ra khỏi đó rằng tôi biết mã bên dưới không an toàn cho chuỗi (sửa: có thể là). Điều tôi đang đấu tranh là tìm ra một triển khai phù hợp và một cách mà tôi thực sự có thể gặp thất bại trong quá trình thử nghiệm. Tôi đang cấu trúc lại một dự án WCF lớn ngay bây giờ cần một số (chủ yếu) dữ liệu tĩnh được lưu trong bộ nhớ cache và được điền từ cơ sở dữ liệu SQL. Nó cần phải hết hạn và "làm mới" ít nhất một lần một ngày, đó là lý do tại sao tôi đang sử dụng MemoryCache.

Tôi biết rằng mã dưới đây không được an toàn cho chuỗi nhưng tôi không thể khiến nó không thành công khi tải nặng và làm phức tạp vấn đề, tìm kiếm trên google hiển thị các triển khai theo cả hai cách (có và không có khóa kết hợp với các cuộc tranh luận xem chúng có cần thiết hay không).

Ai đó có kiến ​​thức về MemoryCache trong môi trường đa luồng có thể cho tôi biết chắc chắn liệu tôi có cần khóa ở nơi thích hợp hay không để lệnh gọi xóa (sẽ hiếm khi được gọi nhưng là yêu cầu của nó) sẽ không xảy ra trong quá trình truy xuất / lặp lại.

public class MemoryCacheService : IMemoryCacheService
{
    private const string PunctuationMapCacheKey = "punctuationMaps";
    private static readonly ObjectCache Cache;
    private readonly IAdoNet _adoNet;

    static MemoryCacheService()
    {
        Cache = MemoryCache.Default;
    }

    public MemoryCacheService(IAdoNet adoNet)
    {
        _adoNet = adoNet;
    }

    public void ClearPunctuationMaps()
    {
        Cache.Remove(PunctuationMapCacheKey);
    }

    public IEnumerable GetPunctuationMaps()
    {
        if (Cache.Contains(PunctuationMapCacheKey))
        {
            return (IEnumerable) Cache.Get(PunctuationMapCacheKey);
        }

        var punctuationMaps = GetPunctuationMappings();

        if (punctuationMaps == null)
        {
            throw new ApplicationException("Unable to retrieve punctuation mappings from the database.");
        }

        if (punctuationMaps.Cast<IPunctuationMapDto>().Any(p => p.UntaggedValue == null || p.TaggedValue == null))
        {
            throw new ApplicationException("Null values detected in Untagged or Tagged punctuation mappings.");
        }

        // Store data in the cache
        var cacheItemPolicy = new CacheItemPolicy
        {
            AbsoluteExpiration = DateTime.Now.AddDays(1.0)
        };

        Cache.AddOrGetExisting(PunctuationMapCacheKey, punctuationMaps, cacheItemPolicy);

        return punctuationMaps;
    }

    //Go oldschool ADO.NET to break the dependency on the entity framework and need to inject the database handler to populate cache
    private IEnumerable GetPunctuationMappings()
    {
        var table = _adoNet.ExecuteSelectCommand("SELECT [id], [TaggedValue],[UntaggedValue] FROM [dbo].[PunctuationMapper]", CommandType.Text);
        if (table != null && table.Rows.Count != 0)
        {
            return AutoMapper.Mapper.DynamicMap<IDataReader, IEnumerable<PunctuationMapDto>>(table.CreateDataReader());
        }

        return null;
    }
}

MS mặc định cung cấp MemoryCachelà hoàn toàn an toàn luồng. Bất kỳ triển khai tùy chỉnh nào bắt nguồn từ đó MemoryCachecó thể không an toàn cho chuỗi. Nếu bạn đang sử dụng MemoryCachengoài hộp, nó sẽ an toàn. Duyệt qua mã nguồn của giải pháp bộ nhớ đệm phân tán nguồn mở của tôi để xem cách tôi sử dụng nó (MemCache.cs):

https://github.com/haneytron/dache/blob/master/Dache.CacheHost/Storage/MemCache.cs

Mặc dù MemoryCache thực sự an toàn cho luồng như các câu trả lời khác đã chỉ định, nhưng nó có một vấn đề đa luồng phổ biến - nếu 2 luồng cố gắng truy cập Get(hoặc kiểm tra Contains) bộ nhớ cache cùng một lúc, thì cả hai sẽ bỏ lỡ bộ nhớ cache và cả hai sẽ kết thúc tạo kết quả và cả hai sau đó sẽ thêm kết quả vào bộ nhớ cache.

Thường thì điều này là không mong muốn - luồng thứ hai nên đợi luồng đầu tiên hoàn thành và sử dụng kết quả của nó thay vì tạo kết quả hai lần.

Đây là một trong những lý do tôi viết LazyCache - một trình bao bọc thân thiện trên MemoryCache để giải quyết các loại vấn đề này. Nó cũng có sẵn trên Nuget .

Như những người khác đã nói, MemoryCache thực sự là một chuỗi an toàn. Tuy nhiên, sự an toàn chuỗi của dữ liệu được lưu trữ bên trong nó, hoàn toàn phụ thuộc vào việc bạn sử dụng nó.

Để trích dẫn Reed Copsey từ bài đăng tuyệt vời của anh ấy liên quan đến đồng thời và ConcurrentDictionary<TKey, TValue>loại. Tất nhiên là có thể áp dụng ở đây.

Nếu hai luồng gọi đây là [GetOrAdd] đồng thời, có thể dễ dàng xây dựng hai phiên bản TValue.

Bạn có thể tưởng tượng rằng điều này sẽ đặc biệt tồi tệ nếu TValueviệc xây dựng tốn kém.

Để giải quyết vấn đề này, bạn có thể tận dụng Lazy<T>rất dễ dàng, điều này thật trùng hợp là rất rẻ để xây dựng. Làm điều này đảm bảo nếu chúng ta rơi vào tình huống đa luồng, rằng chúng ta chỉ đang xây dựng nhiều phiên bản Lazy<T>(giá rẻ).

GetOrAdd()( GetOrCreate()trong trường hợp của MemoryCache) sẽ trả về giống nhau, số ít Lazy<T>cho tất cả các luồng, các trường hợp "bổ sung" của Lazy<T>chỉ đơn giản là bị loại bỏ.

Vì đối tượng Lazy<T>không làm bất cứ điều gì cho đến khi .Valueđược gọi, nên chỉ có một thể hiện của đối tượng từng được xây dựng.

Bây giờ cho một số mã! Dưới đây là một phương pháp mở rộng để IMemoryCachethực hiện những điều trên. Nó tùy ý được thiết lập SlidingExpirationdựa trên một int secondstham số phương thức. Nhưng điều này hoàn toàn có thể tùy chỉnh dựa trên nhu cầu của bạn.

Lưu ý rằng điều này dành riêng cho các ứng dụng .netcore2.0

public static T GetOrAdd<T>(this IMemoryCache cache, string key, int seconds, Func<T> factory)
{
    return cache.GetOrCreate<T>(key, entry => new Lazy<T>(() =>
    {
        entry.SlidingExpiration = TimeSpan.FromSeconds(seconds);

        return factory.Invoke();
    }).Value);
}

Để gọi:

IMemoryCache cache;
var result = cache.GetOrAdd("someKey", 60, () => new object());

Để thực hiện tất cả điều này một cách không đồng bộ, tôi khuyên bạn nên sử dụng cách triển khai tuyệt vời của Stephen ToubAsyncLazy<T> được tìm thấy trong bài viết của anh ấy trên MSDN. Kết hợp trình khởi tạo lười biếng nội trang Lazy<T>với lời hứa Task<T>:

public class AsyncLazy<T> : Lazy<Task<T>>
{
    public AsyncLazy(Func<T> valueFactory) :
        base(() => Task.Factory.StartNew(valueFactory))
    { }
    public AsyncLazy(Func<Task<T>> taskFactory) :
        base(() => Task.Factory.StartNew(() => taskFactory()).Unwrap())
    { }
}   

Bây giờ là phiên bản không đồng bộ của GetOrAdd():

public static Task<T> GetOrAddAsync<T>(this IMemoryCache cache, string key, int seconds, Func<Task<T>> taskFactory)
{
    return cache.GetOrCreateAsync<T>(key, async entry => await new AsyncLazy<T>(async () =>
    { 
        entry.SlidingExpiration = TimeSpan.FromSeconds(seconds);

        return await taskFactory.Invoke();
    }).Value);
}

Và cuối cùng, để gọi:

IMemoryCache cache;
var result = await cache.GetOrAddAsync("someKey", 60, async () => new object());

Kiểm tra liên kết này: http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache(v=vs.110).aspx

Đi tới cuối trang (hoặc tìm kiếm văn bản "An toàn chuỗi").

Bạn sẽ thấy:

^ An toàn chuỗi

Loại này là an toàn chủ đề.

Vừa tải lên thư viện mẫu để giải quyết vấn đề cho .Net 2.0.

Hãy xem repo này:

RedisLazyCache

Tôi đang sử dụng bộ nhớ cache của Redis nhưng nó cũng chuyển đổi dự phòng hoặc chỉ Memorycache nếu thiếu Connectionstring.

Nó dựa trên thư viện LazyCache đảm bảo thực hiện một lệnh gọi lại để ghi trong trường hợp đa luồng cố gắng tải và lưu dữ liệu, đặc biệt nếu lệnh gọi lại rất tốn kém để thực thi.

Như đã đề cập bởi @AmitE trong câu trả lời của @pimbrouwers, ví dụ của anh ấy không hoạt động như được minh họa ở đây:

class Program
{
    static async Task Main(string[] args)
    {
        var cache = new MemoryCache(new MemoryCacheOptions());

        var tasks = new List<Task>();
        var counter = 0;

        for (int i = 0; i < 10; i++)
        {
            var loc = i;
            tasks.Add(Task.Run(() =>
            {
                var x = GetOrAdd(cache, "test", TimeSpan.FromMinutes(1), () => Interlocked.Increment(ref counter));
                Console.WriteLine($"Interation {loc} got {x}");
            }));
        }

        await Task.WhenAll(tasks);
        Console.WriteLine("Total value creations: " + counter);
        Console.ReadKey();
    }

    public static T GetOrAdd<T>(IMemoryCache cache, string key, TimeSpan expiration, Func<T> valueFactory)
    {
        return cache.GetOrCreate(key, entry =>
        {
            entry.SetSlidingExpiration(expiration);
            return new Lazy<T>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
        }).Value;
    }
}

Đầu ra:

Interation 6 got 8
Interation 7 got 6
Interation 2 got 3
Interation 3 got 2
Interation 4 got 10
Interation 8 got 9
Interation 5 got 4
Interation 9 got 1
Interation 1 got 5
Interation 0 got 7
Total value creations: 10

Có vẻ như GetOrCreateluôn trả về mục nhập đã tạo. May mắn thay, điều đó rất dễ sửa:

public static T GetOrSetValueSafe<T>(IMemoryCache cache, string key, TimeSpan expiration,
    Func<T> valueFactory)
{
    if (cache.TryGetValue(key, out Lazy<T> cachedValue))
        return cachedValue.Value;

    cache.GetOrCreate(key, entry =>
    {
        entry.SetSlidingExpiration(expiration);
        return new Lazy<T>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
    });

    return cache.Get<Lazy<T>>(key).Value;
}

Điều đó hoạt động như mong đợi:

Interation 4 got 1
Interation 9 got 1
Interation 1 got 1
Interation 8 got 1
Interation 0 got 1
Interation 6 got 1
Interation 7 got 1
Interation 2 got 1
Interation 5 got 1
Interation 3 got 1
Total value creations: 1

Bộ nhớ cache là an toàn cho luồng, nhưng giống như những người khác đã nêu, có thể GetOrAdd sẽ gọi nhiều loại func nếu gọi từ nhiều loại.

Đây là bản sửa lỗi tối thiểu của tôi về điều đó

private readonly SemaphoreSlim _cacheLock = new SemaphoreSlim(1);

và

await _cacheLock.WaitAsync();
var data = await _cache.GetOrCreateAsync(key, entry => ...);
_cacheLock.Release();