ConcurrentBag<T> 和 lock(List<T>) 添加或删除哪个更快？

Question

我需要对List<T> 执行一些线程安全操作。通常我只是简单地使用：

lock(List<T>)
{
   List<T>.Add();
   List<T>.Remove();
}

我知道还有另一种方法，使用ConcurrentBag<T>。但我不知道哪个更快，或任何其他差异。

编辑：

有些人只是建议我使用ConcurrentBag，因为这样更安全。但我担心这会使我的操作变慢。

我有很多线程需要在List<T> 中添加或删除对象，我想知道哪种方式对性能更好。

Answer 1

您只需尝试一下就可以轻松衡量不同方法的性能！这就是我刚刚得到的：

锁定列表：2.162s
ConcurrentBag：7.264s

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;

public class Test
{
    public const int NumOfTasks = 4;
    public const int Cycles = 1000 * 1000 * 4;

    public static void Main()
    {
        var list = new List<int>();
        var bag = new ConcurrentBag<int>();

        Profile("lock list", () => { lock (list) list.Add(1); });
        Profile("ConcurrentBag", () => bag.Add(1));
    }

    public static void Profile(string label, Action work)
    {
        var s = new Stopwatch();
        s.Start();

        List<Task> tasks = new List<Task>();

        for (int i = 0; i < NumOfTasks; ++i)
        {
            tasks.Add(Task.Factory.StartNew(() =>
            {
                for (int j = 0; j < Cycles; ++j)
                {
                    work();
                }
            }));
        }

        Task.WaitAll(tasks.ToArray());

        Console.WriteLine(string.Format("{0}: {1:F3}s", label, s.Elapsed.TotalSeconds));
    }
}

Answer 2

除非您确定线程的访问模式，否则不要使用ConcurrentBag<T> 替换锁定的List<T>，因为它在后台使用线程本地存储。

MSDN 谈论首选用法：

“ConcurrentBag<T> 是一个线程安全的包实现，针对同一线程将同时生产和使用包中存储的数据的场景进行了优化。”

同样重要的是要注意List<T> 是有序 而ConcurrentBag<T> 是无序。如果您不关心收藏中的顺序，我会使用ConcurrentQueue<T>。

关于性能，下面是来自ConcurrentBag<T> 的一些代码。但是要考虑的主要事情是，如果您执行 Take 并且您的线程本地存储为空，它将从其他线程窃取，这很昂贵。

当它需要窃取时，注意它是锁定的。另请注意，它可以多次锁定一个Take，因为TrySteal 可能会失败并从Steal 多次调用（未显示）。

private bool TrySteal(ConcurrentBag<T>.ThreadLocalList list, out T result, bool take)
{
    lock (list)
    {
        if (this.CanSteal(list))
        {
            list.Steal(out result, take);
            return true;
        }
        result = default (T);
        return false;
    }
}

CanSteal 期间也可能有旋转等待。

private bool CanSteal(ConcurrentBag<T>.ThreadLocalList list)
{
    if (list.Count <= 2 && list.m_currentOp != 0)
    {
        SpinWait spinWait = new SpinWait();
        while (list.m_currentOp != 0)
            spinWait.SpinOnce();
    }
    return list.Count > 0;
} 

最后，即使添加也可能导致锁定。

private void AddInternal(ConcurrentBag<T>.ThreadLocalList list, T item)
{
    bool lockTaken = false;
    try
    {
        Interlocked.Exchange(ref list.m_currentOp, 1);
        if (list.Count < 2 || this.m_needSync)
        {
            list.m_currentOp = 0;
            Monitor.Enter((object) list, ref lockTaken);
        }
        list.Add(item, lockTaken);
    }
    finally
    {
        list.m_currentOp = 0;
        if (lockTaken)
            Monitor.Exit((object) list);
    }
}

Answer 3

List 操作 add 和 remove 是 O(n)，这意味着锁定的持续时间将取决于列表的大小。您的列表越大，您的并发性就越少。但是，如果您总是在末尾添加并从末尾删除，那么您实际上有一个堆栈。在这种情况下，add 和 remove 操作是 O(1) 并且您将拥有更短的锁。

ConcurrentBag 被实现为链表的链表（每个线程一个。操作 add 和 take 是 O(1) 并且在一般情况下不需要锁。事实上锁通常可以避免意味着它可能会更快。