Потоковая повторная инициализация параллельного словаря

Вы правы, ваш код не является потокобезопасным.

1. Вам нужно заблокировать _isBusyUpdating переменную.
2. Вам нужно блокировать _contactIdNames каждый раз, а не только когда это не null.

Также этот код похож на одноэлементный шаблон и имеет ту же проблему с инициализацией. Вы можете решить эту проблему с помощью блокировки с двойной проверкой. Однако вам также потребуется двойная проверка блокировки при доступе к записям.

В случае, когда вы обновляете сразу весь словарь, вам нужно каждый раз блокировать текущее значение при обращении. В противном случае вы можете получить к нему доступ, пока он все еще меняется, и получить ошибку. Поэтому вам либо нужно каждый раз блокировать переменную, либо использовать Interlocked.

Как сообщает MSDN, volatile должен помочь с _isBusyUpdating, он должен быть потокобезопасным.

Если вы не хотите отслеживать _contactIdNames потокобезопасность, попробуйте реализовать обновление каждой записи в том же словаре. Проблема будет в обнаружении разницы между БД и текущими значениями (какие записи были удалены или добавлены, другие можно просто переписать), но не в безопасности потоков, поскольку ConcurrentDictionary уже является потокобезопасным.

Кажется, вы много работаете на себя. Вот как я бы справился с этой задачей:

public class Constructor
{
    private volatile Dictionary<int, string> _contactIdNames;

    public Constructor()
    {
        Observable
            .Interval(TimeSpan.FromSeconds(10.0))
            .StartWith(-1)
            .Select(n =>
            {
                using (var db = new DBEntities())
                {
                    return db.ContactIDs.ToDictionary(
                        x => x.Qualifier * 1000 + x.AlarmCode,
                        x => x.Description);
                }
            })
            .Subscribe(x => _contactIdNames = x);
    }

    public string TryGetValue(int key)
    {
        string value = null;
        _contactIdNames.TryGetValue(key, out value);
        return value;
    }
}

Я использую Microsoft Reactive Extensions (Rx) Framework - NuGet «Rx-Main» - чтобы таймер обновлял словарь.

Rx должен быть довольно простым. Если вы еще не видели это очень простым языком, это похоже на то, что LINQ встречает события.

Если вам не нравится Rx, просто используйте вашу текущую модель таймера.

Весь этот код создает новый словарь каждые 10 секунд из БД. Я просто использую простой словарь, поскольку он создается только из одного потока. Поскольку присвоение ссылок является атомарным, вы можете просто повторно назначить словарь, когда захотите, с полной безопасностью потоков.

Несколько потоков могут безопасно читать из словаря, пока элементы не меняются.

Я хочу знать, является ли следующий код потокобезопасным, хотя я предполагаю, что это не так. И как я могу сделать это потокобезопасным?

Я верю, что это не так. Прежде всего, я бы создал свойство для ConcurrentDictionary и проверил, идет ли обновление внутри метода get, и если да, я бы вернул предыдущую версию объекта:

    private object obj = new object();
    private ConcurrentDictionary<int, string> _contactIdNames;
    private ConcurrentDictionary<int, string> _contactIdNamesOld;
    private volatile bool _isBusyUpdating = false;

    public ConcurrentDictionary<int, string> ContactIdNames
    {
        get
        {
            if (!_isBusyUpdating) return _contactIdNames;

            return _contactIdNamesOld;
        }
        private set 
        {
            if(_isBusyUpdating) _contactIdNamesOld = 
                new ConcurrentDictionary<int, string>(_contactIdNames);

            _contactIdNames = value; 
        }
    }

И ваш метод может быть:

    private static void OnTimedEvent(Object source, System.Timers.ElapsedEventArgs e)
    {
        if (_isBusyUpdating) return;

        lock (obj)
        {

            _isBusyUpdating = true;
            // Get new data values and update the list

            try
            {
                ContactIdNames = new ConcurrentDictionary<int, string>();
                using (var db = new DBEntities())
                {
                    foreach (var item in db.ContactIDs.Select(x => new { x.Qualifier, x.AlarmCode, x.Description }).AsEnumerable())
                    {
                        int key = (item.Qualifier * 1000) + item.AlarmCode;
                        _contactIdNames.TryAdd(key, item.Description);
                    }
                }                    
            }
            catch (Exception e)
            {
                Debug.WriteLine("Error occurred in update ContactId db store", e);        
                _contactIdNames = _contactIdNamesOld;            
            }
            finally 
            {                   
                _isBusyUpdating = false;
            }
        }
    }

P.S.

Меня беспокоит то, что когда я повторно инициализирую словарь, потоки запросов больше не будут потокобезопасными для экземпляра, когда происходит инициализация. По этой причине я использовал блокировку словаря при его обновлении. Однако я не уверен, правильно ли это, поскольку объект изменяется в блокировке?

Этот ConcurrentDictionary<T> тип является потокобезопасным, а не его экземпляром, поэтому даже если вы создадите новый экземпляр и измените ссылку на него - это не повод для беспокойства.