.NET 4.0并发收集性能

Question

我正在尝试编写一个程序,我通过将它们放入不同线程的集合中来安排要删除的项目,并在一个迭代集合的单个线程中清理它们并处理这些项目.

在这样做之前,我想知道什么会产生最佳性能,所以我尝试了ConcurrentBag,ConcurrentStack和ConcurrentQueue,并测量了添加10000000个项目所需的时间.

我使用以下程序来测试这个:

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)
    {
        run(addList);
        run(addBag);
        run(addStack);
        run(addQueue);
        Console.ReadLine();
    }

    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 = # }, action);
        stopwatch.Stop();
        Console.WriteLine(action.Method.Name + " takes " + stopwatch.Elapsed);
    }
}

其中#是使用的线程数.

但结果相当令人困惑:

有8个主题:

• addList需要00:00:00.8166816
• addBag需要00:00:01.0368712
• addStack需要00:00:01.0902852
• addQueue需要00:00:00.6555039

1个主题:

• addList需要00:00:00.3880958
• addBag需要00:00:01.5850249
• addStack需要00:00:01.2764924
• addQueue需要00:00:00.4409501

因此,无论有多少线程,似乎只是锁定一个普通的旧列表比使用任何并发集合更快,除非它可能是队列,如果它需要处理大量写入.

编辑:在下面关于垃圾和调试版本的评论之后:是的,这会影响基准测试.调试构建影响是线性的,垃圾会随着内存使用量的增加而增加.

然而,多次运行相同的测试会得到大致相同的结果.

我在测试运行之前将集合的初始化移到了正确的位置,并在运行后收集垃圾,如下所示:

        list = new List<int>();
        run(addList);
        list = null;
        GC.Collect();

将MaxDegreeOfParallelism设置为8,我得到以下结果:

• addList需要00:00:7959546
• addBag需要00:00:01.08023823
• addStack需要00:00:01.1354566
• addQueue需要00:00:00.6597145

每次运行代码时,给出或减去0.02秒的偏差.

Answer 1

不要忘记，您不必将项目添加到集合中，但也必须检索它们。因此，更公平的比较是基于Monitor的Queue<T>和BlockingCollection<T>之间的比较，每个队列都有 8 个生产者和 1 个消费者。

然后我在我的机器上得到以下结果（我将迭代次数增加了 10 倍）：

• AddQueue1 需要 00:00:18.0119159
• AddQueue2 需要 00:00:13.3665991

但有趣的不仅仅是性能。看一下这两种方法：检查 Add/ConsumeQueue1 的正确性非常困难，而由于BlockingCollection<T>提供的抽象，很容易看出 Add/ConsumeQueue2 完全按照预期执行。

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);
}