试图理解 C# 中的多线程

Question

我正在尝试了解多线程的基础知识，所以我构建了一个小程序，提出了一些问题，我将感谢任何帮助:)

这是小程序：

class Program
{
    public static int count;
    public static int max;
    static void Main(string[] args)
    {
        int t = 0;
        DateTime Result;
        Console.WriteLine("Enter Max Number : ");
        max = int.Parse(Console.ReadLine());
        Console.WriteLine("Enter Thread Number : ");
        t = int.Parse(Console.ReadLine());

        count = 0;

        Result = DateTime.Now;
        List<Thread> MyThreads = new List<Thread>();
        for (int i = 1; i < 31; i++)
        {
            Thread Temp = new Thread(print);
            Temp.Name = i.ToString();
            MyThreads.Add(Temp);
        }

        foreach (Thread th in MyThreads)
            th.Start();

        while (count < max)
        {
        }

        Console.WriteLine("Finish , Took : " + (DateTime.Now - Result).ToString() + " With : " + t + " Threads.");
        Console.ReadLine();
    }

    public static void print()
    {
        while (count < max)
        {
            Console.WriteLine(Thread.CurrentThread.Name + " - " + count.ToString());
            count++;
        }
    }
}

我通过一些测试运行检查了这一点：

我将最大数字设为 100，似乎最快的执行时间是使用 2 个线程，这比使用 10 个线程的时间快 80%。

问题：

1) 线程 4-10 一次都不打印，怎么可能？

2）不应该更多的线程更快吗？

我将最大数量设为 10000 并禁用了打印。

使用这种配置，5 个线程似乎是最快的。

为什么与第一次检查相比有变化？

而且在这种配置（带打印）中，所有线程都会打印几次。 为什么这与仅打印几个线程的第一次运行不同？

有没有办法让所有线程一个一个打印？ 在一条线上或类似的东西？

非常感谢您的帮助：）

Answer 1

您的代码无疑是进入线程世界的第一步，而您刚刚经历了第一个（许多）头痛！

首先， static可以让您在线程之间共享一个变量，但它不是以线程安全的方式这样做的。 这意味着您的count < max表达式和count++不能保证是最新的或线程之间的有效保护。 查看程序的 output max仅为 10（在我的 8 处理器工作站上设置为 4）：

T0 - 0
T0 - 1
T0 - 2
T0 - 3
T1 - 0 // wait T1 got count = 0 too!
T2 - 1 // and T2 got count = 1 too!
T2 - 6
T2 - 7
T2 - 8
T2 - 9
T0 - 4
T3 - 1 // and T3 got count = 1 too!
T1 - 5

对于您关于逐个打印每个线程的问题，我假设您正在尝试协调对count的访问。 您可以使用同步原语（例如 C# 中的lock语句）来完成此操作。 这是对您的代码的天真修改，它将确保仅发生max增量：

static object countLock = new object();

public static void printWithLock()
{
    // loop forever
    while(true)
    {
        // protect access to count using a static object
        // now only 1 thread can use 'count' at a time
        lock (countLock)
        {
            if (count >= max) return;

            Console.WriteLine(Thread.CurrentThread.Name + " - " + count.ToString());
            count++;
        }
    }
}

这个简单的修改使您的程序在逻辑上正确，但也很慢。 该示例现在出现了一个新问题：锁争用。 现在每个线程都在争夺对countLock的访问权。 我们已经使我们的程序线程安全，但没有任何并行性的好处！

线程和并行性并不是特别容易正确处理，但值得庆幸的是，.Net 的最新版本带有任务并行库 (TPL)和并行 LINQ (PLINQ) 。

该库的美妙之处在于转换您当前的代码是多么容易：

var sw = new Stopwatch();

sw.Start();
Enumerable.Range(0, max)
          .AsParallel()
          .ForAll(number =>
               Console.WriteLine("T{0}: {1}",
                                 Thread.CurrentThread.ManagedThreadId,
                                 number));

Console.WriteLine("{0} ms elapsed", sw.ElapsedMilliseconds);

// Sample output from max = 10
// 
// T9: 3
// T9: 4
// T9: 5
// T9: 6
// T9: 7
// T9: 8
// T9: 9
// T8: 1
// T7: 2
// T1: 0
// 30 ms elapsed

上面的 output 有趣地说明了为什么线程会为新用户产生“意外结果”。 当线程并行执行时，它们可能会在不同的时间点完成代码块，或者一个线程可能比另一个线程快。 你永远不会真正了解线程！

Answer 2

您的打印 function 远非线程安全，这就是 4-10 不打印的原因。 所有线程共享相同的 max 和 count 变量。

更多线程会减慢您速度的原因可能是每次处理器更改每个线程之间的焦点时都会发生 state 更改。

此外，当您创建大量线程时，系统需要分配新线程。 大多数情况下，现在建议改用任务，因为它们是从系统管理的线程池中提取的。 因此不一定要分配。 创建一个独特的新线程是相当昂贵的。

无论如何看看这里： http://msdn.microsoft.com/en-us/library/aa645740(VS.71).aspx

Answer 3

仔细看：

    t = int.Parse(Console.ReadLine());

    count = 0;

    Result = DateTime.Now;
    List<Thread> MyThreads = new List<Thread>();
    for (int i = 1; i < 31; i++)
    {
        Thread Temp = new Thread(print);
        Temp.Name = i.ToString();
        MyThreads.Add(Temp);
    }

我认为您错过了一个变量t ( i < 31)。

在编写代码之前，您应该阅读许多有关并行和多线程编程的书籍，因为编程语言只是一种工具。 祝你好运！