4

我正在编写一个压力测试实用程序。在这个实用程序中，我希望我持续加载 10 个线程（共 10,000 个）。这是我的代码

            Stopwatch watch = new Stopwatch();
        watch.Start();

        int itemProcessed = 0;

        do
        {
            List<Task> taskList = new List<Task>();
            for (int i = 0; i < _parallelThreadCount; i++)
            {
                taskList.Add(Task.Factory.StartNew(() => _taskDelegate()));
                itemProcessed++;
            }
            Task.WaitAll(taskList.ToArray());
        } while (itemProcessed < _batchSize);

        watch.Stop();

现在的问题是我使用了 Task.WaitAll，因此最初加载的是 10 个线程，然后是 9、8、7、6、5、4、3、2、1、0。然后我又添加了 10 个线程。

有人可以告诉我如何实现这一目标。

4

2 回答 2

17

Shaamaan 的答案很好，可能是您想要针对特定​​场景使用的答案。我只是提出了一些您可以使用的其他可能选项，这些选项可能更适用于其他情况。

我的博客文章展示了如何使用 Tasks 和 Actions 执行此操作，并提供了一个示例项目，您可以下载并运行以查看两者的实际效果。

有行动

如果使用 Actions，您可以使用内置的 .Net Parallel.Invoke 函数。在这里，我们将其限制为最多并行运行 10 个线程。

var listOfActions = new List<Action>();
for (int i = 0; i < 10000; i++)
{
    // Note that we create the Action here, but do not start it.
    listOfActions.Add(() => DoSomething());
}

var options = new ParallelOptions {MaxDegreeOfParallelism = 10};
Parallel.Invoke(options, listOfActions.ToArray());

有任务

Tasks 没有内置功能。但是，您可以使用我在博客上提供的那个。

    /// <summary>
    /// Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
    /// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
    /// </summary>
    /// <param name="tasksToRun">The tasks to run.</param>
    /// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, CancellationToken cancellationToken = new CancellationToken())
    {
        StartAndWaitAllThrottled(tasksToRun, maxTasksToRunInParallel, -1, cancellationToken);
    }

    /// <summary>
    /// Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
    /// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
    /// </summary>
    /// <param name="tasksToRun">The tasks to run.</param>
    /// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
    /// <param name="timeoutInMilliseconds">The maximum milliseconds we should allow the max tasks to run in parallel before allowing another task to start. Specify -1 to wait indefinitely.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, int timeoutInMilliseconds, CancellationToken cancellationToken = new CancellationToken())
    {
        // Convert to a list of tasks so that we don&#39;t enumerate over it multiple times needlessly.
        var tasks = tasksToRun.ToList();

        using (var throttler = new SemaphoreSlim(maxTasksToRunInParallel))
        {
            var postTaskTasks = new List<Task>();

            // Have each task notify the throttler when it completes so that it decrements the number of tasks currently running.
            tasks.ForEach(t => postTaskTasks.Add(t.ContinueWith(tsk => throttler.Release())));

            // Start running each task.
            foreach (var task in tasks)
            {
                // Increment the number of tasks currently running and wait if too many are running.
                throttler.Wait(timeoutInMilliseconds, cancellationToken);

                cancellationToken.ThrowIfCancellationRequested();
                task.Start();
            }

            // Wait for all of the provided tasks to complete.
            // We wait on the list of "post" tasks instead of the original tasks, otherwise there is a potential race condition where the throttler&#39;s using block is exited before some Tasks have had their "post" action completed, which references the throttler, resulting in an exception due to accessing a disposed object.
            Task.WaitAll(postTaskTasks.ToArray(), cancellationToken);
        }
    }

然后创建任务列表并调用函数让它们运行，一次最多同时运行 10 个，你可以这样做：

var listOfTasks = new List<Task>();
for (int i = 0; i < 10000; i++)
{
    var count = i;
    // Note that we create the Task here, but do not start it.
    listOfTasks.Add(new Task(() => Something()));
}
Tasks.StartAndWaitAllThrottled(listOfTasks, 10);
于 2016-04-29T08:01:57.790 回答
13

如果你可以稍微重构你的代码（阅读：替换你的do while循环），你可以使用Parallelclass。这是一个简单的例子：

List<int> data = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Parallel.ForEach(data, new ParallelOptions() { MaxDegreeOfParallelism = 10 }, d =>
{
    Console.WriteLine(d);
});

您可能最感兴趣的一点是MaxDegreeOfParallelism属性ParallelOptions- 它指定可以同时运行多少个线程。

编辑：

由于您没有任务列表，而只是想多次重复相同的操作，因此您可以使用Parallel.For. 代码可能如下所示：

int repeatCount = 100;
int itemProcessed = 0;
Parallel.For(0, repeatCount, new ParallelOptions() { MaxDegreeOfParallelism = 10 }, i =>
{
    _taskDelegate();
    System.Threading.Interlocked.Increment(ref itemProcessed);
});

请注意，如果您使用的唯一原因itemProcessed是检查循环的工作时间，您可以安全地从上面的代码中删除这两行。

于 2013-07-23T07:43:45.527 回答