ConcurrentDictionary ishlatmasdan Dictionary qanday…

ConcurrentDictionary dan foydalanmasdan oqimga xavfsiz Dictionary ni amalga oshirish uchun System.Threading nom space dan sinxronizatsiya primitivlaridan foydalanish mumkin.

Asosiy yondashuvlar:

Butun lug'atni bloklash (lock): Barcha o'qish va yozish operatsiyalarini bir xil sinxronizatsiya ob'ekti bilan lock blokiga o'rash.

// Lug'atga kirishni sinxronlashtirish uchun ob'ekt
private readonly object _lockObject = new object();
private readonly Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>();

public void AddOrUpdate(TKey key, TValue value)
{
    lock (_lockObject)
    {
        if (_dictionary.ContainsKey(key))
        {
            _dictionary[key] = value;
        }
        else
        {
            _dictionary.Add(key, value);
        }
    }
}

public bool TryGetValue(TKey key, out TValue value)
{
    lock (_lockObject)
    {
        return _dictionary.TryGetValue(key, out value);
    }
}

public bool TryRemove(TKey key, out TValue value)
{
    lock (_lockObject)
    {
        if (_dictionary.TryGetValue(key, out value))
        {
            _dictionary.Remove(key);
            return true;
        }
        return false;
    }
}

Afzalliklari: Oddiy amalga oshirish. Kamchiliklari: Yuqori konkurentsiyada past samaradorlik, chunki o'qish operatsiyalari ham butun lug'atga bloklanadi.

ReaderWriterLockSlim dan foydalanish: O'qish va yozish operatsiyalari uchun bloklarni ajratishga imkon beradi. Bir nechta oqim bir vaqtning o'zida o'qiy oladi, lekin faqat biri yozishi mumkin.

private readonly ReaderWriterLockSlim _lockSlim = new ReaderWriterLockSlim();
private readonly Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>();

public void AddOrUpdate(TKey key, TValue value)
{
    _lockSlim.EnterWriteLock();
    try
    {
        if (_dictionary.ContainsKey(key))
        {
            _dictionary[key] = value;
        }
        else
        {
            _dictionary.Add(key, value);
        }
    }
    finally
    {
        _lockSlim.ExitWriteLock();
    }
}

public bool TryGetValue(TKey key, out TValue value)
{
    _lockSlim.EnterReadLock();
    try
    {
        return _dictionary.TryGetValue(key, out value);
    }
    finally
    {
        _lockSlim.ExitReadLock();
    }
}

public bool TryRemove(TKey key, out TValue value)
{
    _lockSlim.EnterWriteLock();
    try
    {
        if (_dictionary.TryGetValue(key, out value))
        {
            _dictionary.Remove(key);
            return true;
        }
        return false;
    }
    finally
    {
        _lockSlim.ExitWriteLock();
    }
}

Afzalliklari: lock bilan solishtirganda, o'qish operatsiyalari intensiv bo'lsa, yaxshiroq ishlash. Kamchiliklari: Oddiy lock bilan solishtirganda, murakkabroq amalga oshirish.

Ushbu yondashuvlar orasidan tanlov, lug'atning foydalanish xususiyatlariga, o'qish va yozish operatsiyalarining nisbati va ishlash talablariga bog'liq. ReaderWriterLockSlim odatda tez-tez o'qish operatsiyalari bo'lsa, afzalroq bo'ladi.

ConcurrentDictionary ishlatmasdan Dictionary qanday amalga oshiriladi?