C#中的线程之线程同步

写在前面

之前写过一篇博客，C#中的线程之Abort陷阱，最近比较忙，没时间写后面的内容，恰好今天偶然看到一个技术问答。线程抢占执行怎么使10-20连续输出 。回答该问题顺便写了几个例子，于是就有了这篇博客。

问题描述

主要解决的问题是让两个线程代码能按照一定的顺序执行。题主抛出的代码是这样的：

// 需要让打印出来的结果顺序输出
 static void Main(string[] args)
        {

            Thread th = new Thread(() =>
                {
                    for (int i = 0; i < 10; i++) 
                    {
                        Console.WriteLine(i);
                        Thread.Sleep(100);
                    }
                });
            Thread th2 = new Thread(() =>
            {
                th.Join();
                for (int i = 10; i < 20; i++)
                {
                    Console.WriteLine(i);
                    Thread.Sleep(100);
                }
            });
            th.Start(); 
            th2.Start(); 

        }

输出：
10
0
1
11
12
2
13
3
14
4
15
5
16
6
17
7
8
18
9
19

问题分析

原代码中开启了两个线程，一个顺序输出0-9，另一个顺序输出10-20，由于是两个不同的线程，那么原问题就可以转换成两个线程之间的顺序执行。要实现这个功能，.NetFramework提供了很多的方法，我在此就抛砖引玉，给出几种我比较熟悉的方法。

解决方案

方案一
在初始线程的位置等待线程完成。
即在线程一执行完毕后，再开启线程二的执行。
th.Start();
th.Join();
th2.Start();
这种方法的优点是简单，缺点是不易扩展，若线程1与线程2都需要同时执行某段代码，或线程12的执行不希望影响主线程的执行。
所以我们一定还有更好的方法实现这样的效果

方案二
在线程二执行时等待。
即在线程二开启后，等待线程一的完成。代码如下：

static void Main(string[] args)
        {

            Thread th = new Thread(() =>
                {
                    for (int i = 0; i < 10; i++) 
                    {
                        Console.WriteLine(i);
                        Thread.Sleep(100);
                    }
                });
            Thread th2 = new Thread(() =>
            {
                th.Join();
                for (int i = 10; i < 20; i++)
                {
                    Console.WriteLine(i);
                    Thread.Sleep(100);
                }
            });
            th.Start(); 
            th2.Start();
            Console.WriteLine("线程启动完毕！"); 

        }

此方法的优点正好弥补了方案一的缺点，但它的缺点是我们必须知道线程1的实例。这在实际项目中有可能就很麻烦了，
如果有10个这样的线程需要进行同步执行。那10个线程都需要知道上一个线程的实例，并在自己的线程中等待。
这样写代码是难以读懂并维护的。就着代码简洁的原则，我们也需要考虑其它的实现方式。

方案三
使用锁来实现。代码如下：

 static void Main(string[] args)
        {
            object ThreadLocker =new  object();
            Thread th = new Thread(() =>
                {
                    lock (ThreadLocker)
                    {
                        for (int i = 0; i < 10; i++)
                        {
                            Console.WriteLine(i);
                            Thread.Sleep(100);
                        }
                    }
                });
            Thread th2 = new Thread(() =>
            {
                lock (ThreadLocker)
                {
                    for (int i = 10; i < 20; i++)
                    {
                        Console.WriteLine(i);
                        Thread.Sleep(100);
                    }
                }
            });

            Thread th3 = new Thread(() =>
            {
                lock (ThreadLocker)
                {
                    for (int i = 20; i < 30; i++)
                    {
                        Console.WriteLine(i);
                        Thread.Sleep(100);
                    }
                }
            });
            th.Start();
            while (th.ThreadState != ThreadState.Running)
            {
                //Console.WriteLine("等待线程1执行"); 
            }
            th2.Start();
            while (th2.ThreadState != ThreadState.Running)
            {
                //Console.WriteLine("等待线程2执行");
            }
            th3.Start();
            while (th3.ThreadState != ThreadState.Running)
            {
                //Console.WriteLine("等待线程3执行");
            }
            Console.WriteLine("线程启动完毕！"); 

        }

线程锁来决定对资源的互斥，注意代码中在主线程中用while判断线程的状态是为了达到线程顺序启动的目的（因为在多核的情况下，线程的执行顺序是不确定的）。
注意这里开了三个线程，在while等待的时候我起初准备使用Console.WriteLine来打印确定时序，实际发现这样并不能精准反映时序。因为这里涉及到Console.WriteLine的线程安全问题，
此问题不在本题讨论范围内，可以考虑使用System.Diagnostics.Debug.WriteLine在调试状态下查看输出窗口。
还有个要注意的是： 主线程的执行还是会阻塞！虽然只有很少的时间，若主线程少量阻塞不影响程序的功能，那这种方法是可行的，但若对要求较高，那我们还得考虑其它方法。

方案四
使用信号量，信号量也是常用的线程同步方案之一。

 static void Main(string[] args)
        {
            int iThreadNum = 3;
            AutoResetEvent[] evts = new AutoResetEvent[iThreadNum];
            for (int i = 0; i < iThreadNum; i++)
            {
                evts[i] = new AutoResetEvent(false);
            } 
            Thread th = new Thread(() =>
             {  
                 for (int i = 0; i < 10; i++)
                 {
                     Console.WriteLine(i);
                     Thread.Sleep(100);
                 }
                 evts[0].Set();
             });
            Thread th2 = new Thread(() =>
            { 
                evts[0].WaitOne();  
                for (int i = 10; i < 20; i++)
                {
                    Console.WriteLine(i);
                    Thread.Sleep(100);
                }
                evts[1].Set();
            });

            Thread th3 = new Thread(() =>
            {
                evts[1].WaitOne(); 
                for (int i = 20; i < 30; i++)
                {
                    Console.WriteLine(i);
                    Thread.Sleep(100);
                } 
            });
            th3.Start();
            th2.Start();
            th.Start();
            Console.WriteLine("线程启动完毕！"); 

        }

使用信号量其实与第二种方法有些类似，不过这种方式更加灵活，不用等到线程结束。

总结

好了，我要说的就这么多了，.NetFramework作为一个比较成熟的技术提供的线程同步方案特别多，若有兴趣建议多查查文档。在文档里我们能收获很多东西。

ps：本文中的代码只看懂测试，实际这样写代码我是会很生气的！