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

并发集合并不总是更快。他们中的更多人只看到更高级别争用的性能提升，实际工作量也会产生影响。查看pfx团队的这篇论文：）

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

谨防过早优化。将一些有用的东西放在一起然后进行优化特别是因为实际工作量很重要。另外，将锁作为性能瓶颈是相当有用的，通常有一些io或其他算法需要更长时间:) :)

Answer 2

不要忘记，您不必将项目添加到集合中，还必须检索它们。因此，更公平的比较是基于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);
}

Answer 3

我希望看到添加和拍摄的性能比较。这是我使用的代码：

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

Answer 4

是的，但要点是，您需要多个线程并发，并发并发地长时间运行以查看平均性能，因为这并未考虑不同集合的锁定策略。

.NET 4.0并发收集性能

4 个答案: