Question

我正在尝试测试C＃parallel方法，这是我的测试程序：

class Program
{
    static int counter;
    static void Main(string[] args)
    {
        counter = 0;
        Parallel.Invoke(
            () => func(1),
            () => func(2),
            () => func(3)
            );
        Console.Read();
    }


    static void func(int num)
    {
        for (int i = 0; i < 5;i++ )
        {
            Console.WriteLine(string.Format("This is function #{0} loop. counter - {1}", num, counter));
            counter++;
        }
    }
}

我尝试做的是拥有1个静态共享变量，每个函数实例将增加1个。

我希望按counter顺序打印(1,2,3,...) 但输出结果令人惊讶：

This is function #1 loop. counter - 0
This is function #1 loop. counter - 1
This is function #1 loop. counter - 2
This is function #1 loop. counter - 3
This is function #1 loop. counter - 4
This is function #3 loop. counter - 5
This is function #2 loop. counter - 1
This is function #3 loop. counter - 6
This is function #3 loop. counter - 8
This is function #3 loop. counter - 9
This is function #3 loop. counter - 10
This is function #2 loop. counter - 7
This is function #2 loop. counter - 12
This is function #2 loop. counter - 13
This is function #2 loop. counter - 14

任何人都可以向我解释为什么会这样吗？

Answer 1

问题是您的代码不是线程安全的。例如，可能发生的是：

功能＃2获取counter的值，以便在Console.WriteLine()
功能＃1获取counter的值，调用Console.WriteLine()，增加counter
功能＃1获取counter的值，调用Console.WriteLine()，增加counter
函数＃2最终使用旧值

Console.WriteLine()

此外，++本身不是线程安全的，因此最终值可能不是15。

要解决这两个问题，您可以使用Interlocked.Increment()：

for (int i = 0; i < 5; i++)
{
    int incrementedCounter = Interlocked.Increment(ref counter);
    Console.WriteLine("This is function #{0} loop. counter - {1}", num, incrementedCounter);
}

这样，您将在增量后获得数字，而不是原始代码中的数字。此外，此代码仍然不会以正确的顺序打印数字，但您可以确保每个数字只打印一次。

如果您确实希望以正确的顺序输入数字，则需要使用lock：

private static readonly object lockObject = new object(); … for (int i = 0; i < 5; i++) { lock (lockObject) { Console.WriteLine("This is function #{0} loop. counter - {1}", num, counter); counter++; } }

当然，如果你这样做，你实际上不会得到任何并行性，但我认为这不是你真正的代码。

Answer 2

实际上会发生什么 - Invoke只是将这些任务排队，运行时为这些任务分配线程，为它提供了很多随机元素（哪一个将首先被拾取等）。

甚至msdn文章都说明了这一点：

此方法可用于执行一组可能并行的操作。不保证操作执行的顺序或它们是否并行执行。在完成每个提供的操作之前，此方法不会返回，无论是否由于正常或异常终止而发生完成。

Answer 3

这个问题看起来很多线程访问同一个变量。这是一个并发问题。你可以尝试一下：

    static object syncObj = new object();
    static void func(int num)
    {
        for (int i = 0; i < 5; i++)
        {
            lock (syncObj)
            {
                Console.WriteLine(string.Format("This is function #{0} loop. counter - {1}", num, counter));
                counter++;
            }
        }
    }

使用Parallel.Invoke和静态变量时的奇怪行为

3 个答案: