C#线程

1. 创建一个线程
using System;
using System.Threading;
 
namespace ConsoleApplication1
{
    class App
    {
        public void run()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(i.ToString());
            }
        }
 
        static void Main(string[] args)
        {
            Console.WriteLine("App Start");
 
            App app = new App();
            ThreadStart ts = new ThreadStart(app.run);
            Thread t = new Thread(ts);
 
            t.Start();
            Console.WriteLine("App end");
        }
    }
}
 
2. 为线程设置名字
Thread有Name属性，可以设置它的名字。
 
3. Sleep函数
Sleep函数被调用时，该线程所占用的系统资源，一般来说是CPU，会被释放掉，从而其他线程可以得到一些资源以进行响应的操作。
 
4. 设置线程优先级
可以通过设置Priority属性来控制线程的优先级。但是我们对线程的运行次序永远无法做到真正控制，因为这个控制权主要在于操作系统。我们只能在整体上使一个线程获得更多或更少的运行机会而已。而并不是说在任何一个特定的时刻，一个高优先级的线程就一定会先于一个低优先级的线程被运行。
 
5. 线程的后台与前台运行
所谓运行在后台是说该线程与产生它的父进程紧密联系在一起，它隐藏在父进程的后面，所以一旦父进程终止运行，该线程本身也会被立即终止，不管线程是否已经真正结束。相反，一个运行在前端的线程却是独立于产生它的父进程，一旦该进程开始运行，即使父进程已经终止运行，这个线程却会照样独立运行，直到运行结束或者被其他程序强制终止。C#中的一个线程的默认设置为前台运行。
 
6. 终止一个进程
       6.1我们可以使用Abort方法来强行终止一个线程
       6.2 一个更好的方法是通过设置一个标志来告诉线程自动终止，程序如下
using System;
using System.Threading;
 
namespace ConsoleApplication1
{
    class App
    {
        private bool bContinue = true;
 
        public void run()
        {
            Thread t = Thread.CurrentThread;
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(t.Name + ": " + i.ToString());
                Thread.Sleep(1);
                if (!bContinue)
                {
                    return;
                }
            }
        }
 
        static void Main(string[] args)
        {
            Console.WriteLine("App Start");
 
            App app = new App();
            ThreadStart ts1 = new ThreadStart(app.run);
            Thread t1 = new Thread(ts1);
 
            t1.Name = "T1";
            t1.Start();
 
            Thread.Sleep(5);
 
            app.bContinue = false;
 
            Console.WriteLine("App end");
        }
    }
}
 
7. 线程的暂停与再运行
使用Suspend方法，我们可以暂停一个线程，如果要重新激活它，则使用Resume方法。
 
8. 线程Join函数
在激活一个线程后，我们可以等待该线程运行结束，或者设置一个最长的等待时间。只有等线程自动结束或者已经运行超过了前面预先设定的时间后，才去接着运行后面的程序。
using System;
using System.Threading;
 
namespace ConsoleApplication1
{
    class App
    {
        public void run()
        {
            Thread t = Thread.CurrentThread;
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(t.Name + ": " + i.ToString());
                Thread.Sleep(10);
            }
        }
 
        static void Main(string[] args)
        {
            Console.WriteLine("App Start");
 
            App app = new App();
            ThreadStart ts1 = new ThreadStart(app.run);
            ThreadStart ts2 = new ThreadStart(app.run);
            Thread t1 = new Thread(ts1);
            Thread t2 = new Thread(ts2);
 
            t1.Name = "T1";
            t2.Name = "T2";
            t1.Start();
            t1.Join(40);
            t2.Start();
            t2.Join();
 
            Console.WriteLine("App end");
        }
    }
}
在这个程序中，T1运行40微秒后，T2才有机会运行，而主程序则是一直等待T2结束后，才去运行最后一个打印语句。
 
9. 线程加锁
线程加锁可以放置同一时刻，多个线程对资源的争夺。使它们能够正确的访问资源。
using System;
using System.Threading;
 
namespace ConsoleApplication1
{
    class App
    {
        public int i = 0;
        public int j = 0;
        public int Limit = 100;
        public void Increase()
        {
            while (i < Limit)
            {
                i++;
                Thread.Sleep(1);
                j++;
            }
        }
 
        public void Check()
        {
            while (i < Limit)
            {
                if (i != j)
                {
                    Console.WriteLine("i != j, i = {0}, j = {1}", i, j);
                    Thread t = Thread.CurrentThread;
                    t.Abort();
                }
                Thread.Sleep(1);
            }
        }
 
        static void Main(string[] args)
        {
            App app = new App();
 
            Thread t1 = new Thread(new ThreadStart(app.Increase));
            Thread t2 = new Thread(new ThreadStart(app.Increase));
            Thread t3 = new Thread(new ThreadStart(app.Check));
 
            t1.Start();
            t2.Start();
            t3.Start();
        }
    }
}
在这个例子中，我们看到，每当i被加1时，j也总是被同时加1，所以看来i与j应该永远相等，可事实上，我们得到如下结果：
i != j, i = 2, j = 0
原因在于，i与j的累加和i与j的检测发生在两个不同的线程中。可能发生的情况是，在一愕嘎线程中i刚被累加过，但是j还没有；或者是前两个线程互相覆盖了累加的结果（假设在某一点上，线程A与线程B同时读取i的值为5，此时，j的值也是5，但两个线程都还没有去读取它，然后线程A将i加上1，即i的值变为6，可是同样的，线程B又在5的基础上将i加1，再次将i设置为6，所以i最终被设置为6。但是两个线程对j的读取却是错开进行的，也就是说当线程A将j的值改变为6后，线程B才去读取，从而发现j的值为6，并在此基础上将其加1，最终将j的值设定为7）。这样在测试程序中，便发现i与j的值不等了。这便是线程之间的资源共享问题。
C#为解决资源共享问题引进了Monitor的概念，也就是说，在某个线程要运行一段程序前先得获取一个监控器，从而通知其他线程不可能同时再运行这同一段程序。比如，上面的例子中的Increase函数可以修改如下：
public void Increase()
        {
            while (i < Limit)
            {
                try
                {
                    Monitor.Enter(this);
                    i++;
                    Thread.Sleep(1);
                    j++;
                }
                finally
                {
                    Monitor.Exit(this);
                }
            }
        }
这样便解决了两个累加线程之间相互覆盖的问题。可是这样i与j还是可能不等，我们必须给检测函数也加一个监控器。这样无论何时，ij总是相等的了。
再实际应用中，我们总是将Monitor.Enter与Monitor.Exit同时运用，C#又提供了lock语句来实现对一段程序的加锁，因而程序可以简化为
public void Increase()
        {
            while (i < Limit)
            {
                lock (this)
                {
                    i++;
                    Thread.Sleep(1);
                    j++;
                }
            }
        }
同样要lock住Check函数。
注意：虽然我们对这两个函数加了锁，但是我们还是不能保证任何适合ij的值在任何程序中都是相等的。比如我们添加一个函数，然后添加一个线程。ij就可能不等了。所以，最彻底的解决办法是，对i和j的访问加锁。最终的程序如下：
using System;
using System.Threading;
 
namespace ConsoleApplication1
{
    class App
    {
        public int i = 0;
        public int j = 0;
        public int Limit = 100;
        public void Increase()
        {
            while (i < Limit)
            {
                lock (this)
                {
                    i++;
                    Thread.Sleep(1);
                    j++;
                }
            }
        }
 
        public int I
        {
            get
            {
                lock (this)
                {
                    return i;
                }
            }
            set
            {
                lock (this)
                {
                    i = value;
                }
            }
        }
 
        public int J
        {
            get
            {
                lock (this)
                {
                    return j;
                }
            }
            set
            {
                lock (this)
                {
                    j = value;
                }
            }
        }
 
        public void Check()
        {
            while (I < Limit)
            {
                if (I != J)
                {
                    Console.WriteLine("I != J, I = {0}, J = {1}", I, J);
                    Thread t = Thread.CurrentThread;
                    t.Abort();
                }
                Thread.Sleep(1);
            }
        }
 
        static void Main(string[] args)
        {
            App app = new App();
 
            Thread t1 = new Thread(new ThreadStart(app.Increase));
            Thread t2 = new Thread(new ThreadStart(app.Increase));
            Thread t3 = new Thread(new ThreadStart(app.Check));
 
            t1.Start();
            t2.Start();
            t3.Start();
        }
    }
}