3

我有一个 .NET 4.5 单实例 WCF 服务，它维护一个列表中的项目集合，该列表将同时具有并发的读取器和写入器，但读取器比写入器多得多。

我目前正在决定是使用 BCLConcurrentBag<T>还是使用我自己的自定义通用ThreadSafeList类（它扩展IList<T>和封装了 BCL ReaderWriterLockSlim，因为它更适合多个并发读取器）。

通过模拟 100 万个读者（简单地运行 Sum Linq 查询）和只有 100 个写者（将项目添加到列表中）的并发场景来测试这些实现时，我发现了许多性能差异。

对于我的性能测试，我有一个任务列表：

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

测试 1：如果我使用以下代码创建 1m 个读取器任务，然后创建 100 个写入器任务：

tasks.AddRange(Enumerable.Range(0, 1000000).Select(n => new Task(() => { temp.Where(t => t < 1000).Sum(); })).ToArray());
tasks.AddRange(Enumerable.Range(0, 100).Select(n => new Task(() => { temp.Add(n); })).ToArray());

我得到以下计时结果：

  • 并发包：~300ms
  • 线程安全列表：~520ms

测试 2：但是，如果我创建 1m 个读取器任务和 100 个写入器任务（其中要执行的任务列表可能是 {Reader,Reader,Writer,Reader,Reader,Writer 等}

foreach (var item in Enumerable.Range(0, 1000000))
{
    tasks.Add(new Task(() => temp.Where(t => t < 1000).Sum()));
    if (item % 10000 == 0)
        tasks.Add(new Task(() => temp.Add(item)));
}

我得到以下计时结果：

  • 并发包：~4000ms
  • 线程安全列表：~800ms

我获取每个测试的执行时间的代码如下：

Stopwatch watch = new Stopwatch();
watch.Start();
tasks.ForEach(task => task.Start());
Task.WaitAll(tasks.ToArray());
watch.Stop();
Console.WriteLine("Time: {0}ms", watch.Elapsed.TotalMilliseconds);

测试 1 中 ConcurrentBag 的效率更好，测试 2 中 ConcurrentBag 的效率比我的自定义实现差，因此我发现使用哪个是一个艰难的决定。

Q1。当我唯一改变的是列表中任务的顺序时，为什么结果如此不同？

Q2。有没有更好的方法来更改我的测试以使其更公平？

4

1 回答 1

2

当我唯一改变的是列表中任务的顺序时，为什么结果如此不同？

我最好的猜测是它Test #1实际上并没有阅读项目，因为没有什么可阅读的。任务执行顺序为：

  1. 从共享池中读取 1M 次并计算总和
  2. 写入共享池 100 次

您Test # 2混合了读取和写入，这就是为什么，我猜，您会得到不同的结果。

有没有更好的方法来更改我的测试以使其更公平？

在开始任务之前，请尝试将任务的顺序随机化。可能很难重现相同的结果，但您可能会更接近真实世界的使用情况。

最终，您的问题是关于乐观并发（Concurrent*类）与悲观并发（基于锁）的区别。根据经验，当您同时访问共享资源的机会较低时，更喜欢乐观并发。当同时访问的机会很高时，更喜欢悲观的。

于 2015-05-29T13:58:04.060 回答