Производительность параллельной коллекции .NET 4.0

Параллельные коллекции не всегда быстрее. большинство из них видят прирост производительности только на более высоких уровнях конкуренции, и фактическая рабочая нагрузка также оказывает влияние. Ознакомьтесь с этой статьей от команды pfx :)

http://blogs.msdn.com/b/pfxteam/archive/2010/04/26/9997562.aspx

Остерегайтесь преждевременной оптимизации. собрать что-то вместе, что работает, а затем оптимизировать. тем более, что фактическая нагрузка важна. Кроме того, иметь блокировки в качестве узкого места производительности довольно сложно, обычно есть какой-то io или другой алгоритм, который занимает гораздо больше времени :)

Не забывайте, что вам нужно не только добавлять элементы в коллекцию, но и извлекать их. Таким образом, более справедливо сравнение между монитором на основе Queue‹T› и BlockingCollection‹T›, в каждой из которых 8 производителей и 1 потребитель.

Затем я получаю следующие результаты на своей машине (я увеличил количество итераций в 10 раз):

• AddQueue1 занимает 00:00:18.0119159
• AddQueue2 занимает 00:00:13.3665991

Но интересна не только производительность. Взгляните на два подхода: очень сложно проверить правильность Add/ConsumeQueue1, в то время как очень легко увидеть, что Add/ConsumeQueue2 делает именно то, что задумано, благодаря абстракции, предоставляемой BlockingCollection‹T›.

static Queue<int> queue1 = new Queue<int>();
static BlockingCollection<int> queue2 = new BlockingCollection<int>();

static void Main(string[] args)
{
    Run(AddQueue1, ConsumeQueue1);
    Run(AddQueue2, ConsumeQueue2);
    Console.ReadLine();
}

private static void AddQueue1(int obj)
{
    lock (queue1)
    {
        queue1.Enqueue(obj);
        if (queue1.Count == 1)
            Monitor.Pulse(queue1);
    }
}

private static void ConsumeQueue1()
{
    lock (queue1)
    {
        while (true)
        {
            while (queue1.Count == 0)
                Monitor.Wait(queue1);
            var item = queue1.Dequeue();
            // do something with item
        }
    }
}

private static void AddQueue2(int obj)
{
    queue2.TryAdd(obj);
}

private static void ConsumeQueue2()
{
    foreach (var item in queue2.GetConsumingEnumerable())
    {
        // do something with item
    }
}

private static void Run(Action<int> action, ThreadStart consumer)
{
    new Thread(consumer) { IsBackground = true }.Start();
    Stopwatch stopwatch = Stopwatch.StartNew();
    Parallel.For(0, 100000000, new ParallelOptions() { MaxDegreeOfParallelism = 8 }, action);
    stopwatch.Stop();
    Console.WriteLine(action.Method.Name + " takes " + stopwatch.Elapsed);
}

Я хотел увидеть сравнение производительности как при добавлении, так и при взятии. Вот код, который я использовал:

class Program
{
    static List<int> list = new List<int>();
    static ConcurrentBag<int> bag = new ConcurrentBag<int>();
    static ConcurrentStack<int> stack = new ConcurrentStack<int>();
    static ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
    static void Main(string[] args)
    {
        list = new List<int>();
        run(addList);
        run(takeList);

        list = null;
        GC.Collect();

        bag = new ConcurrentBag<int>();
        run(addBag);
        run(takeBag);

        bag = null;
        GC.Collect();

        stack = new ConcurrentStack<int>();
        run(addStack);
        run(takeStack);

        stack = null;
        GC.Collect();

        queue = new ConcurrentQueue<int>();
        run(addQueue);
        run(takeQueue);

        queue = null;
        GC.Collect();

        Console.ReadLine();
    }

    private static void takeList(int obj)
    {
        lock (list)
        {
            if (list.Count == 0)
                return;

            int output = list[obj];
        }
    }

    private static void takeStack(int obj)
    {
        stack.TryPop(out int output);
    }

    private static void takeQueue(int obj)
    {
        queue.TryDequeue(out int output);
    }

    private static void takeBag(int obj)
    {
        bag.TryTake(out int output);
    }

    private static void addList(int obj) { lock (list) { list.Add(obj); } }

    private static void addStack(int obj) { stack.Push(obj); }

    private static void addQueue(int obj) { queue.Enqueue(obj); }

    private static void addBag(int obj) { bag.Add(obj); }



    private static void run(Action<int> action)
    {
        Stopwatch stopwatch = Stopwatch.StartNew();
        Parallel.For(0, 10000000, new ParallelOptions()
        {
            MaxDegreeOfParallelism = 8
        }, action);
        stopwatch.Stop();
        Console.WriteLine(action.Method.Name + " takes " + stopwatch.Elapsed);
    }
}

И вывод:

• addList занимает 00:00:00.8875893
• takeList занимает 00:00:00.7500289
• addBag занимает 00:00:01.8651759
• takeBag занимает 00:00:00.5749322
• addStack занимает 00:00:01.5565545
• takeStack занимает 00:00:00.3838718
• addQueue занимает 00:00:00.8861318
• takeQueue занимает 00:00:01.0510706

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