C#线程

线程

　　线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。

　　多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。

　　多线程可以提高CPU的利用率。在多线程程序中，一个线程必须等待的时候，CPU可以运行其它的线程而不是等待，这样就大大提高了程序的效率。

　　在 C# 中，System.Threading.Thread 类用于线程的工作。线程生命周期开始于System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。

　　我们在编写线程程序时首先要引入System.Threading空间。

创建线程

　　当 C# 程序开始执行时，主线程自动创建。使用 Thread 类创建的线程被主线程的子线程调用。通过Start()方法来启动线程。如下面例子：

using System;
using System.Threading;
namespace test
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Main start");
/*=========================================/
Thread 类拥用4个重载的构造函数，常用的一个接收一个ThreadStart类型的参数
public Thread ( ThreadStart start)
ThreadStart是一个委托，定义如下
public delegate void ThreadStart()
/=========================================*/
Thread th = new Thread(new ThreadStart(ThreadMethod));
//也可简写为new Thread(ThreadMethod);
th.Start(); //启动线程
for (char i = 'a'; i < 'k'; i++)
{
Console.WriteLine("Main Thread: {0}", i);
Thread.Sleep(100);
}
th.Join(); //主线程等待辅助线程结束
Console.WriteLine("Main Thread end.");
}
static void ThreadMethod()
{
Console.WriteLine("Second Thread start...");
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Second Thread：{0}", i);
Thread.Sleep(200);
}
Console.WriteLine("Second Thread end.");
}
}
}

后台线程

　　在默认情况下，用Thread类创建的线程是前台线程。在用thread类创建线程时,可以设置IsBackground属性,以确定该线程是前台线程还是后台线程。将线程的IsBackgrond属性设置为false(默认值） 。

　　程序运行结果为：



　　当我们将IsBackground属性值改为true时，有时可以看到与上面相同的运行结果——新线程的启动消息，但没有结束消息。去试一试吧，后台线程特别适合于完成后台任务，如关闭word等。

控制线程

　　C#的Thread类为我们提供了几个重要的方法来控制线程：

　　Start()：启动线程；

　　Sleep(int)：静态方法，暂停当前线程指定的毫秒数；

　　Abort()：通常使用该方法来终止一个线程；

　　Suspend()：该方法并不终止未完成的线程，它仅仅挂起线程，以后还可恢复；

　　Resume()：恢复被Suspend()方法挂起的线程的执行。

　　例如在前面中我们已经使用了Sleep函数。

线程的优先级

　　当线程之间争夺CPU时间时，CPU 是按照线程的优先级给予服务的。在C#应用程序中，用户可以设定5个不同的优先级，由高到低分别是Highest，AboveNormal，Normal，BelowNormal，Lowest，在创建线程时如果不指定优先级，那么系统默认为ThreadPriority.Normal。

　　给一个线程指定优先级，我们可以使用如下代码：

Thread myThread = new Thread(ThreadMethod); //声明线程
myThread.Priority=ThreadPriority.Lowest; //设定优先级为最低

lock

　　当我们使用线程的时候，效率最高的方式当然是异步，即各个线程同时运行，其间不相互依赖和等待。但当不同的线程都需要访问某个资源的时候，就需要同步机制了，也就是说当对同一个资源进行读写的时候，我们要使该资源在同一时刻只能被一个线程操作，以确保每个操作都是有效即时的，也即保证其操作的原子性。lock是C#中最常用的同步方式，格式为:lock(objectA){codeB} 。

using System;
using System.Threading;
namespace test
{
class Program
{
static void Main(string[] args)
{
threda t = new threda();
threda.obj.i = 10;
Thread th1 = new Thread(new ThreadStart(t.hhh));
th1.Name = "th1";
th1.Start();

Thread th2 = new Thread(new ThreadStart(t.hhh));
th2.Name = "th2";
th2.Start();
Console.ReadKey();
}
}
class threda
{
public static sss obj = new sss();

public void hhh()
{
lock (obj) //lock锁
{
for (int i = 0; i < 7; i++)
{
Thread.Sleep(500);

if (obj.i > 0)
{
obj.i--;
Console.WriteLine("Current Thread Name: " + Thread.CurrentThread.Name + ", obj.i= " + obj.i);
}
}
}
}
}

class sss
{
public int i;
}
}

　　通过设定线程的优先级，我们可以安排一些相对重要的线程优先执行，例如对用户的响应等等。