class ThreadTest {static void Main() {Thread t = new Thread (WriteY);t.Start();                         // Run WriteY on the new thread//同时，主线程做其他事情while (true) Console.Write ("x");  // Write 'x' forever
  }static void WriteY() {while (true) Console.Write ("y");  // Write 'y' forever
  }
}

static void Main() {new Thread (Go).Start();      // Call Go() on a new threadGo();                        // Call Go() on the main thread
}static void Go() {// Declare and use a local variable - 'cycles'for (int cycles = 0; cycles < 5; cycles++) Console.Write ('?');
}

class ThreadTest
{bool done;  static void Main()
{ThreadTest tt = new ThreadTest();  // Create a common instance （tt作为他们共同的一个实例对象）new Thread (tt.Go).Start(); //新线程调用tt.Go(); //主线程调用
 }// Note that Go is now an instance method（实例方法）void Go()
{if (!done) { done = true; Console.WriteLine ("Done"); }}
}

class ThreadTest {static bool done;   // Static fields are shared between all threadsstatic void Main() {new Thread (Go).Start();Go();}static void Go() {if (!done) { done = true; Console.WriteLine ("Done"); }}
}

static void Go() {if (!done) { Console.WriteLine ("Done"); done = true; }
}

class ThreadSafe {static bool done;static readonly object locker = new object();static void Main() {new Thread (Go).Start();Go();}static void Go() {lock (locker) {if (!done) { Console.WriteLine ("Done"); done = true; }}}
}

static void Main()
{Thread t = new Thread (Go);t.Start();t.Join();Console.WriteLine ("Thread t has ended!");
}static void Go()
{for (int i = 0; i < 1000; i++) Console.Write ("y");
}

2.    创建和开始使用线程

线程用Thread类来创建，

一、通过ThreadStart委托来指明方法从哪里开始运行，下面是ThreadStart委托如何定义的：【也可以不用】

public delegate void ThreadStart();

调用Start方法后，线程开始运行，线程一直到它所调用的方法返回后结束。下面是一个例子，使用了C#的语法创建TheadStart委托：

class ThreadTest {static void Main() {Thread t = new Thread (new ThreadStart (Go));t.Start();  // Run Go() on the new thread.Go();       // Simultaneously run Go() in the main thread.
  }static void Go() { Console.WriteLine ("hello!"); }

在这个例子中，线程t执行Go()方法，大约与此同时主线程也调用了Go()，结果是两个几乎同时hello被打印出来：

二、一个线程可以仅通过指定一个方法来方便的创建，然后C#指出线程开始的方法（不用明确使用委托也可以，例如前面的例子）

 Thread t = new Thread (Go);    // No need to explicitly use ThreadStart

在这种情况，ThreadStart被编译器自动推断出来，


三、另一个快捷方式是使用一个lambda表达式或匿名方法：

static void Main()
{Thread t = new Thread ( () => Console.WriteLine ("Hello!") );t.Start();
}

  将数据传入ThreadStart中

最简单的方法传递参数到一个线程：是执行一个lambda表达式,调用该方法所需的参数

static void Main()
{Thread t = new Thread ( () => Print ("Hello from t!") );t.Start();
}static void Print (string message)
{Console.WriteLine (message);
}

使用这种方法,您可以将任意数量的参数传递给方法。你甚至可以把整个实现包在一个多语句λ表达式中

new Thread (() =>
{Console.WriteLine ("I'm running on another thread!");Console.WriteLine ("This is so easy!");
}).Start();

使用匿名方法 同样可以

new Thread (delegate()
{...
}).Start();

另一种方法是：在Thread’s Start（）方法中传参数

static void Main()
{Thread t = new Thread (Print);t.Start ("Hello from t!");
}static void Print (object messageObj)
{string message = (string) messageObj;   // We need to cast here
  Console.WriteLine (message);
}

因为线程的构造函数重载， 接受两种委托

public delegate void ThreadStart();
public delegate void ParameterizedThreadStart (object obj);

话又说回来，在上面的例子里，我们想更好地区分开每个线程的输出结果，让其中一个线程输出大写字母。我们传入一个状态字到Go中来完成整个任务，但我们不能使用ThreadStart委托，因为它不接受参数，所幸的是，.NET framework定义了另一个版本的委托叫做ParameterizedThreadStart， 它可以接收一个单独的object类型参数（通常需要参数转换）

Lambda表达式和捕获变量：

正如我们所见,一个lambda表达式是最强大的方式传递数据到一个线程。然而,您必须小心线程开始后变量的意外修改,因为这些变量都是共享的。例如,考虑以下:

for (int i = 0; i < 10; i++)new Thread (() => Console.Write (i)).Start();

输出是非确定的!  例如：224458891010  （后面的数不小于前面的数，在1-10之间的数，10次循环开了10个线程）

Here’s a typical result:

The problem is that the i variable refers to the same memory location throughout the loop’s lifetime（循环周期时 两个线程捕获的是同一个内存地址区）. Therefore, each thread calls Console.Write on a variable whose value may change as it is running!

The solution is to use a temporary variable as follows:

for (int i = 0; i < 10; i++)
{int temp = i;new Thread (() => Console.Write (temp)).Start();
}

变量temp位于每个循环迭代。因此,每个线程捕捉不同的内存位置（主线程捕获i的内存区，子线程捕获temp的内存区）这样就没问题。。（0123456789）

We can illustrate the problem in the earlier code more simply with the following example:

string text = "t1";
Thread t1 = new Thread ( () => Console.WriteLine (text) );text = "t2";
Thread t2 = new Thread ( () => Console.WriteLine (text) );t1.Start();
t2.Start();

Because both lambda expressions capture the same text variable, t2 is printed twice:

t2
t2

  命名线程

线程可以通过它的Name属性进行命名，这非常有利于调试：可以用Console.WriteLine打印出线程的名字，Microsoft Visual Studio可以将线程的名字显示在调试工具栏的位置上。线程的名字可以在被任何时间设置，但只能设置一次，重命名会引发异常。

程序的主线程也可以被命名，下面例子里主线程通过CurrentThread属性命名：

class ThreadNaming {static void Main() {Thread.CurrentThread.Name = "main";Thread worker = new Thread (Go);worker.Name = "worker";worker.Start();Go();}static void Go() {Console.WriteLine ("Hello from " + Thread.CurrentThread.Name);}
}

结果也有可能相反，不能保证哪个先输出。线程由操作系统来调度，每次哪个线程先运行可能不同。

  前台和后台线程

创建的线程默认为前台线程（而线程池中的线程总是后台线程），这意味着任何一个前台线程在运行都会保持程序存活。然而后台线程不是。一旦所有的前台线程结束，程序也就结束了，任何后台线程也将突然停止。。

一个线程的前台/后台状态  与他的优先级或分配执行时间没有关系。。

改变线程从前台到后台不会以任何方式改变它在CPU协调程序中的优先级和状态。

线程的IsBackground属性控制它的前后台状态，如下实例：

class PriorityTest {static void Main (string[] args) {Thread worker = new Thread (delegate() { Console.ReadLine(); });if (args.Length > 0) worker.IsBackground = true;worker.Start();}
}

1、如果程序被调用的时候没有任何参数，工作线程为前台线程，并且将等待ReadLine语句来等待用户按回车来触发，这期间，主线程退出，但是程序保持运行，因为一个前台线程仍然活着。

2、 另一方面如果有参数传入Main()，工作线程被赋为后台线程，当主线程结束程序立刻退出，终止了ReadLine。后台线程终止的这种方式，使任何最后操作都被规避了，这种方式是不太合适的。好的方式是明确等待任何后台工作线程完成后再结束程序，有两种方法解决：

a、对创建的线程调用Join()方法，让其他等待它的结束

b、在线程池中的话，用一个事件等待来处理

在这两种情况下,你应该指定一个超时（timeout）,所以可以放弃一个叛离线程（出于某种原因拒绝完成任务的线程）。

拥有一个后台工作线程是有益的，最直接的理由是它当提到结束程序它总是可能有最后的发言权。

对于程序失败退出的普遍原因就是存在“被忘记”的前台线程。

  线程优先级

线程的Priority 属性确定了线程相对于其它同一进程的活动的线程拥有多少执行时间，以下是级别：

enum ThreadPriority { Lowest, BelowNormal, Normal, AboveNormal, Highest }

注意：提升一个线程的优先级之前要仔细想想—它可能导致其他线程的资源缺乏等问题

设置一个线程的优先级为高一些，并不意味着它能执行实时的工作，因为它受限于程序的进程的级别。要执行实时的工作，必须提升在System.Diagnostics 命名空间下Process的级别，像下面这样：

using (Process p = Process.GetCurrentProcess())p.PriorityClass = ProcessPriorityClass.High;

ProcessPriorityClass.High 实际上是一个等级的最高优先级：Realtime（实时）。设置进程级别到Realtime通知操作系统：你不想让你的进程被抢占了。如果你的程序进入一个偶然的死循环，可以预期，操作系统被锁住了，除了关机没有什么可以拯救你了！基于此，High大体上被认为最好的选择实时进程级别。

如果一个实时的程序有一个用户界面，提升进程的级别是不太好的，因为当用户界面UI过于复杂的时候，界面的更新耗费过多的CPU时间，拖慢了整台电脑。

（虽然在写这篇文章的时候,在互联网电话程序Skype侥幸地这么做, 也许是因为它的界面相当简单吧。）

降低主线程的级别、提升进程的级别、确保实时线程不进行界面刷新，但这样并不能避免电脑越来越慢，因为操作系统仍会拨出过多的CPU给整个进程。最理想的方案是使实时工作和用户界面在不同的进程（拥有不同的优先级）运行，通过Remoting或共享内存方式进行通信，共享内存需要Win32 API中的 P/Invoking。(可以搜索看看CreateFileMapping 和 MapViewOfFile)

  异常处理

  任何线程创建范围内try/catch/finally块，当线程开始执行便不再与其有任何关系。考虑下面的程序：

public static void Main() {try {new Thread (Go).Start();}catch (Exception ex) {// 不会在这得到异常Console.WriteLine ("Exception!");}static void Go() { throw null; }
}

这里try/catch语句一点用也没有，新创建的线程将引发NullReferenceException异常。当你考虑到每个线程有独立的执行路径的时候，便知道这行为是有道理的，

补救方法是在线程处理的方法内加入他们自己的异常处理：


public static void Main() {new Thread (Go).Start();
}static void Go() {try {...throw null;     // 这个异常在下面会被捕捉到
    ...}catch (Exception ex) {记录异常日志，并且或通知另一个线程我们发生错误...}

从.NET 2.0开始，任何线程内的未处理的异常都将导致整个程序关闭，这意味着忽略异常不再是一个选项了。因此为了避免由未处理异常引起的程序崩溃，try/catch块需要出现在每个线程进入的方法内，至少要在产品程序中应该如此。