Thread-safe структуры данных .NET 4 (ч. 1)

Автор: Topol Воскресенье, Май 6th, 2012 Нет комментариев

Рубрика: Операционные системы

.NET 4 содержит богатый набор средств, упрощающих распараллеливание кода. Если мы начинаем обрабатывать некоторый набор данных одновременно в нескольких потоках, то автоматически поднимается вопрос о синхронизации выполнения этих потоков, в частности о том, где хранить результаты обработки. Существует достаточно способов координировать потоки между собой, и всегда можно реализовать любой из них. Но создатели Parallel Extensions уже позаботились об этом, и в состав .NET  4 был включен ряд «потокобезопасных» структур данных. Реализован набор наиболее популярных коллекций, с которыми я и предлагаю ознакомиться.


1. Очередь: ConcurrentQueue<T>
Этот класс представляет собой классическую очередь, работающую по принципу FIFO, с той лишь разницей, что к ней возможен безопасный доступ со стороны нескольких потоков. Новой «параллельной» природе соответствует и набор методов — получение элемента производится посредством вызова Try*:

Код:
ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
queue.Enqueue(10);

int t;
Console.WriteLine(queue.TryPeek(out t));
Console.WriteLine(queue.TryDequeue(out t));

Как можно догадаться по названию, отличаются эти вызовы тем, что TryPeek() оставляет элемент в очереди, а TryDequeue() извлекает его. Оба метода возвращают false если элемент получить не удалось, иначе — true. Добавление элемента производится с помощью метода Enqueue() — здесь ничего особенного нет. С помощью свойств Count и IsEmpty можно узнать количество элементов в очереди, и есть ли они вообще.

2. Стек: ConcurrentStack<T>
Здесь дело обстоит точно так же, как и с очередью — имеем дело с обычным стеком, но наделенным возможностью конкурентного доступа. Кроме принципа LIFO, использующегося в стеке, отличительной чертой его является возможность добавления и извлечения нескольких элементов:

Код:
ConcurrentStack<int> stack = new ConcurrentStack<int>();
stack.Push(10);
stack.PushRange(new int[] { 1, 2, 3, 4, 5 });
int t;
if (stack.TryPop(out t))
{
Console.WriteLine(«Pop: » + t);
}
if (stack.TryPeek(out t))
{
Console.WriteLine(«Peek: » + t);
}
int[] ts = new int[5];
int count;
if ((count = stack.TryPopRange(ts, 0, 3)) > 0)
{
Console.WriteLine(«PopRange»);
for (int i = 0; i < count; i++)
{
Console.WriteLine(ts[i]);
}
}

Вот результат работы этого участка кода:

Методы TryPeek() и TryPop() возвращают bool значения, а TryPopRange() — количество извлеченных элементов. Можно положить в стек сразу несколько элементов посредством вызова PushRange().

3. Коллекция: ConcurrentBag<T>
Представляет собой неупорядоченное хранилище данных, и этим похоже на множество, хотя отличается от него тем, что может хранить дублирующиеся элементы. В отличие от предыдущих структур не гарантируется какой-либо порядок извлечения элементов. Это, наверное, самая простая коллекция из всего набора:

Код:
ConcurrentBag<int> bag = new ConcurrentBag<int>(new int[] { 1, 1, 2, 3 });
bag.Add(70);

int t;
bag.TryPeek(out t);
Console.WriteLine(t);

bag.Add(110);
Console.WriteLine();
for (int i = 0; i < 3; i++)
{
bag.TryTake(out t);
Console.WriteLine(t);
}

Этот кусочек кода даст следующий вывод на консоль:

Глядя на результат, может сложиться ощущение, что коллекция следует принципу LIFO. Ещё раз подчеркну, что это не гарантируется. Никакого определённого порядка. Обратите внимание на конструктор — есть возможность задать начальный набор элементов. То же самое можно сделать при создании очереди и стека.

4. Словарь: ConcurrentDictionary<TKey, TValue>
И здесь просматриваются черты «старого знакомого» — да, это реализация привычного Dictionary<TKey, TValue>, но с возможностью конкурентного доступа. Разумеется, наделение такими способностями не прошло даром — немного изменился привычный набор методов. Давайте его рассмотрим, для этого создадим коллекцию:

Код:
ConcurrentDictionary<string, string>
dict = new ConcurrentDictionary<string, string>();
dict.TryAdd(«name», «OFC340″);
dict.TryAdd(«age», «25″);dict.TryAdd(«age», «25″);

Работа по добавлению/изменению/удалению элементов производится с помощью методов Try*, которые вернут true, если действие выполнено прошла успешно, иначе false. В данном случае добавление значения с ключом «age» будет в первый раз успешно, а во второй — нет, при этом никаких исключений сгенерировано не будет. Например, попытка получить значение по ключу, которого нет в словаре:

Код:
string t = string.Empty;
Console.WriteLine(dict.TryGetValue(«nokey», out t));

приведет лишь к выводу на консоль строки «False». Удаление элемента будет выглядеть так:

Код:
Console.WriteLine(dict.TryRemove(«age», out t));

С помощью свойств Values и Keys можно получить актуальные на момент вызова коллекции ключей и значений словаря. На этом вся специфика «потокобезопасной» версии заканчивается.

Как видите, в реализации рассмотренных нами коллекций нет никакой «мега»-функциональности, только необходимые вещи. Мне нравятся такие решения — когда строятся базовые структуры, нагромождение лишних возможностей лишь мешает. В случае необходимости всегда можно дополнить их нужным поведением.

Кроме указанных, в текущей версии .NET beta 1 есть двусвязный список ConcurrentLinkedList<T>. Однако, я не буду на нём останавливаться, поскольку в MSDN нас заботливо предупредили: «ConcurrentLinkedList(of T) is planned to be removed prior to the final release of Visual Studio 2010. Please do not use this class», т.е. этот список будет исключен и в финальной версии .NET 4.0 его не будет. Поэтому тратить время на его рассмотрение не стоит (хотя, смотреть там особо нечего — «конкурентная» версия известного LinkedList<T>).

Представленные выше 4 структуры данных — самые простые, и на них я завершу первую часть обзора. Во второй части речь пойдёт о более интересном хранилище — BlockingCollection<T>.

Источник: thevista.ru

Оставить комментарий

Чтобы оставлять комментарии Вы должны быть авторизованы.

Похожие посты