Question

仅出于知识目的，我如何验证n个方法是否并行执行？

Parallel.For(0, 10, i => DoSomething(i));

...

void DoSomething(int par)
{
    Console.WriteLine($"Test: {par}");
}

是否有测试可以向我保证DoSomething不会按顺序执行（如果Console.WriteLine不是一个好的测试，那么可能是一个非常简单的测试函数？）

Answer 1

在您的示例中，方法肯定是顺序的，因为.NET控制台将synchronize calls from different threads。

但是，您可以使用Thread.ManagedThreadID或Environment.CurrentManagedThreadId（对于.NET 4.5）检查运行该方法的线程ID

class Program
{
    static void Main(string[] args)
    {
        // first run with default number of threads
        Parallel.For(0, 10, i => DoSomething(i));
        Console.ReadLine();

        // now run with fewer threads...
        Parallel.For(0, 10, new ParallelOptions{ 
                                  MaxDegreeOfParallelism = 2 
                                }, i => DoSomething(i));
        Console.ReadLine();
    }

    static void DoSomething(int par)
    {
        int i = Environment.CurrentManagedThreadId;
        // int i = Thread.ManagedThreadId;  -- .NET 4.0 and under
        Thread.Sleep(200);
        Console.WriteLine("Test: "+ par.ToString() + 
                          ", Thread :" + i.ToString());
    }
}

如果你在没有Thread.Sleep的情况下运行它，你会注意到只会使用几个线程，因为调用将足够快地完成，以便线程及时返回到池中以获取下一个作业由队列分发。

添加sleep将延迟线程（模拟工作）足够长的时间，以便线程池必须获取更多线程以及时将作业分离出来。

当并行运行任何任务时，很容易检查这些任务实际上是否都在不同的线程中运行。但是，您是否获得性能优势将取决于这些线程的工作效率。正如您所见，某些操作会调用共享资源上的争用（例如写入控制台），并可能阻止您的多个线程同时运行。

其他争用来源可能是，例如，内存分配 - 如果您的线程都在大量分配和解除分配内存，那么他们最终可能会花费大量时间等待轮到内存管理器。这将限制您将实现的实际并行度。

Answer 2

您可以使用以下代码检查在paralel中执行的方法数量：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ParallelMethodsCounter
{
    class Program
    {
        public static int _parallelCounter = 0;
        public static int _maxParallelExecutionsCount = 0;

        static void Main(string[] args)
        {
            Parallel.For(0, 10, i => DoSomething(i));
            Console.WriteLine("MAX PARALLEL EXECUTIONS: {0}", _maxParallelExecutionsCount);
        }

        public static void DoSomething(int par)
        {
            int currentParallelExecutionsCount = Interlocked.Increment(ref _parallelCounter);
            InterlockedExchangeIfGreaterThan(ref _maxParallelExecutionsCount, currentParallelExecutionsCount, currentParallelExecutionsCount);
            Console.WriteLine("Current parallel executions: {0}", currentParallelExecutionsCount);
            try
            {
                //Do your work here
            }
            finally
            {
                Interlocked.Decrement(ref _parallelCounter);
            }
        }

        public static bool InterlockedExchangeIfGreaterThan(ref int location, int comparison, int newValue)
        {
            int initialValue;
            do
            {
                initialValue = location;
                if (initialValue >= comparison) return false;
            }
            while (Interlocked.CompareExchange(ref location, newValue, initialValue) != initialValue);
            return true;
        }
    }
}

但请记住，Parallel.For不会尝试并行执行太多，因为它使用线程池，默认情况下它使用的线程数等于处理器内核数。在我的四核机器上，我通常有2-4次并行执行，有时最多执行5次（当然这里没有严格限制）。

Answer 3

不确定我是否理解你想做什么。你可以算一下。

Parallel.For(0, 10, i => DoSomething(i));

...

private static int parallelCounter = 0;
private static object counterLockObject = new Object();
void DoSomething(int par)
{
    int myCounter;
    lock(counterLockObject)
    {
        myCounter = ++parallelCounter;
    }
    try
    {
        // you probably need something that takes more time to
        // see anything executing in parallel
        Console.WriteLine("Current number of parallel threads: {0}", myCounter);
    }
    finally
    {
        lock(counterLockObject)
        {
            parallelCounter--;
        }        
    }
}

如何验证n个方法是否并行执行？

3 个答案: