14.2.1 创建一个线程
实例化一个Thread对象，然后调用它的Start方法，就可以创建和启动一个新的线程。最简单的Thread构造方法是接受一个ThreadStart代理：一个无参方法，表示执行开始位置。
//System.Threading.ThreadStart 委托，它表示此线程开始执行时要调用的方法
public Thread(ThreadStart start);
示例：
static void Main(string[] args)
{
Thread t = new Thread(WriteY); //创建一个新线程
t.Start(); //启动线程 WriteY
//同时，主线程也会执行。
for (int i = 0; i < 1000; i++) Console.Write("x");
Console.Read();
}
static void WriteY()
{
for (int i = 0; i < 1000; i++) Console.Write("y");
}
- 线程启动后，
IsAlive属性变为True，直到线程停止。- 当
Thread的构造函数接收的代理执行完毕，线程会停止。- 停止后，线程无法再启动。
每个线程都有一个Name属性，可用于调试。只能设置一次，修改线程名称会抛出异常。
静态属性Thread.CurrentThread可以返回当前执行的线程：
Console.Write(Thread.CurrentThread.Name);
14.2.2 联合与休眠
等待另一个线程结束时，可以调用另一个现成的Join方法：
static void Main(string[] args)
{
Thread t = new Thread(Go);
t.Start();
t.Join();
Console.WriteLine("线程 t 已经结束");
Console.Read();
}
static void Go() { for (int i = 0; i < 1000; i++) Console.Write("y"); }
打印1000次“y”，然后再接着打印“线程 t 已经结束”。调用Join时，可以指定一个超时时间。然后，它会在线程结束时返回true，或者超时时返回false。
Thread.Sleep(TimeSpan.FromHours(1));//休眠1小时
调用Thread.Sleep(0)，会马上放弃线程当前时间片，自动将CPU交给其他线程。Thread.Yield()方法也有相同的效果，但是它只会将资源交给同一处理器上运行的线程。
14.2.3 阻塞
线程阻塞是指线程由于特定原因暂停执行，如Sleeping或执行Join后等待另一个线程停止。阻塞的线程会立刻交出（yield）它的处理器时间片，然后从这时开始不再消耗处理器时间，直至阻塞条件结束。使用线程的ThreadState属性，可以测试线程的阻塞状态：
1.I/O密集与计算密集
如果一个操作将大部分时间用于等待一个条件的发生，那么就称为I/O密集（I/O-bound）操作。
相反，如果一个操作将大部分时间用于执行CPU秘籍操作，那么就称为计算密集（compute-bound）操作。
2.阻塞与自旋
I/O密集操作可以以两种方式执行：
同步等待当前线程的操作完成（如Console.ReadLine、Thread.Sleep或Thread.Join），或者异步执行，然后在将来操作完成时触发一个回调函数。
异步等待的I/O密集操作会将大部分时间花费在线程阻塞上。它们可能在一个定期循环中自旋：
while(DateTime < nextStartTime)
Thread.Sleep(100);
14.2.4 本地状态与共享状态
CLR会给每一个线程分配独立的内存堆，从而保证本地变量的隔离。下例定义一个方法，其中包含一个局部（本地）变量，然后同时在主线程和新创建的线程上调用这个方法：
static void Main(string[] args)
{
new Thread(Go).Start(); //在 新线程 上调用GO
Go(); //在 主线程 调用GO
Console.Read();
}
static void Go()
{
for (int cycles = 0; cycles < 5; cycles++)
{
Console.Write('?');
}
}
每一个线程的内存堆会创建cycles变量副本，所以输出结果为10个问号。
如果线程拥有一个对象实例的通用引用，那么这些线程就共享相同的数据：
class ThreadTest
{
bool _done;
static void Main(string[] args)
{
ThreadTest tt = new ThreadTest();
new Thread(tt.GO).Start();
tt.GO();
Console.Read();
}
void GO()
{
if (!_done)
{
_done = true;
Console.WriteLine("Done");
}
}
}
因为这两个线程都在同一个ThreadTest实例上调用GO()，所以它们共享_done域。因此，“Done”只会打印一次，而不会打印两次。
其它方式：
编译器会将Lambda表达式或匿名代理捕获的局部变量转为域，所以它们也可以共享。
静态域是在线程之间共享数据的另一种方法。
14.2.5 锁与线程安全
class ThreadSafe
{
static bool _done;
static readonly object _locker = new object();
static void Main(string[] args)
{
new Thread(Go).Start();
Go();
Console.Read();
}
static void Go()
{
lock (_locker)
{
if (_done)
{
Console.WriteLine("Done");
_done = true;
}
}
}
}
结果：（什么都没有）
当两个线程同时争夺一个锁时（它可以是任意引用类型的对象，这里是_locker），其中一个线程会等待（或阻塞），直到锁释放。这个例子保证一次只会一个线程进入它的代码块，因此“Done”只会打印一次。
在复杂多线程环境中，采用这种方式来保护代码就是具有线程安全性。
锁并不是解决线程安全的万能法宝 —— 人们很容易在访问域时忘记锁，而且锁本身也存在一些问题（如死锁）。
14.2.6 传递数据到线程
给线程启动方法传递一些参数。最简单是使用Lambda表达式，然后用指定参数调用这个方法：
static void Main()
{
Thread t = new Thread(() => Print("Hello from t!"));
t.Start();
}
static void Print(string message) { Console.WriteLine(message); }
这种方法可以给这个方法传递任意数量的参数。甚至可以将整个实现过程封装在一个多语句Lambda表达式中
new Thread (() =>
{
Console.WriteLine ("I'm running on another thread!");
Console.WriteLine ("This is so easy!");
}).Start()
Lambda表达式与捕获的变量
在线程启动之后，一定要注意小心修改捕捉的变量。
for (int i = 0; i < 10; i++)
new Thread(() => Console.Write(i)).Start();
这段代码输出结果不确定，下面是一种常见的：
问题是，在整个循环过程中，变量i都指向同一块内存地址。因此，每次线程调用Console.Write处理变量时，这个变量的值可能发生了变化！解决方法是使用临时变量：
for (int i = 0; i < 10; i++)
{
int temp = i;
new Thread (() => Console.Write (temp)).Start();
}
变量temp是每个循环过程的局部变量，因此，每一个线程都会获取完全不同的内存地址。
String text = "t1";
Thread t1 = new Thread(()=>Console.WriteLine(text));
text = "t2";
Thread t2 = new Thread(() => Console.WriteLine(text));
t1.Start();t2.Start();
结果：t2 t2
由于两个Lambda表达式补货同一个text变量，所以t2会打印两次。
14.2.7 异常处理
线程创建时任何生效的try/catch/finally语句块在线程执行后都与线程无关。
static void Main(string[] args)
{
try
{
new Thread(Go).Start();
}
catch (Exception)
{
//代码永远不会运行到这里
Console.WriteLine("exception");
}
}
static void Go() { throw null; } //抛出异常
解决方法 是将异常处理移动到Go方法内：
static void Main(string[] args)
{
new Thread(Go).Start();
}
static void Go()
{
//throw null;
try
{
throw null;//下面补货到异常 NullReferemceException
}
catch (Exception ex)
{
//通常是记录异常，并且/或者发信号给另一个线程，告诉它们捕捉到了异常
Console.WriteLine("exception");
}
}
结果： exception
集中式异常处理
WPF、Metro和Windows窗体应用程序都支持订阅全局异常处理事件，分别是Application.DispatcherUnhandledException和Application.ThreadException。如果通过消息循环调用的程序中出现未处理异常（相当于Application激活时运行在主线程上的所有代码）。就会触发这些异常。这非常适合记录日志和报告缺陷（但是它不会触发非UI线程的未处理异常）。处理这些事件可防止程序意外关闭，但必须选择重启应用。
AppDomain.CurrentDomain.UnhandledException可以触发任意线程的任意未处理异常，CLR 2.0开始会在事件执行完后关闭应用程序。在程序配置文件中添加下面代码，可防止应用程序关闭：
<configuration>
<runtime>
<legacyUnhandledExceptionPolicy enabled="1" />
</runtime>
</configuration>
14.2.8 前台线程与后台线程
默认显示创建的线程为前台线程，使用线程的IsBackground属性。
前台线程：只有所有的前台线程都关闭才能完成程序关闭。（主线程一直是前台线程）
后台线程：只要所有的前台线程都结束，后台线程自动结束（CLR会强制结束所有仍运行的后台线程，却不会抛出异常）。
14.2.9 线程优先级
线程的Priority属性可以确定它与其他激活线程的相对执行时间长短，
public enum ThreadPriority
{
Lowest = 0,
BelowNormal = 1,
Normal = 2,
AboveNormal = 3,
Highest = 4,
}
如果希望一个线程拥有比其他进程的线程更高的优先级，还必须使用System.Diagnostics的Process类，提高进程本身优先级：
worker.Priority = ThreadPriority.Highest;
//进程
using (Process p = Process.GetCurrentProcess())
{
p.PriorityClass = ProcessPriorityClass.High;
}
14.2.10 发送信号
有时候，一个线程需要等待其他线程的通知，这就是发送信号（signaling）。最简单的发送信号结构是ManualResetEvent。在一个ManualResetEvent上调用WaitOne，可以阻塞当前线程，使之一直等待另一个线程通过调用Set“打开”信号。
下面例子启动一个线程，等待ManualResetEvent到达，它会保持阻塞2秒钟，直至主线程发送信号：
static void Main(string[] args)
{
//通知一个或多个正在等待的线程已发生事件,如果为 true，则将初始状态设置为终止
var signal = new ManualResetEvent(false);
new Thread(() =>
{
Console.WriteLine("等待 signal..");
signal.WaitOne(); //阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号
signal.Dispose(); //释放由 System.Threading.WaitHandle 类的当前实例使用的所有资源。
Console.WriteLine("开始signal");
}).Start();
Thread.Sleep(2000);
signal.Set(); //打开信号 ---（将事件状态设置为终止状态，允许一个或多个等待线程继续）
Console.Read();
}
调用Set后，信号仍然保持打开；调用Reset，就可以再次将它关闭。
14.2.12 同步上下文
System.ComponentModel 命名空间中有一个抽象类 SynchronizationContext。它实现了线程编列的一般化。
WPF、Metro和Windows窗体都定义和实例化了SynchronizationContext的子类，当运行在UI线程时，它通过静态属性SynchronizationContext.Current获得。
Framework2.0引入了
BanckgroundWoker类，他使用SynchronizationContext类简化富客户端应用程序的工作者线程。
BanckgroundWoker增加了相同的Tasks和异步功能，它也使用SynchronizationContext。
14.2.13 线程池
无论何时启动一个线程，都需要一定时间（几百毫秒）用于创建新的局部变量堆。
线程池（thread pool）预先创建一组可回收线程，因此可以缩短这个过载时间。要实现高效的并行编程和细致的并发性，必须使用线程池。
考虑：
1. 由于不能设置池化线程的Name，因此会增加代码调试难度。
2. 池化线程通常都是后台线程。
3. 池化线程阻塞会影响性能。
1.进入线程池
在池化线程运行代码最简单的方法是使用Task.Run：
Task.Run(() => Console.WriteLine("Hello from the thread pool"));
Framework 4.0之前不支持任务，所以改为调用ThreadPool.QueueUserWorkItem
ThreadPool.QueueUserWorkItem(notUsed => Console.WriteLine("Hello"));
2.线程池整洁性
线程池还有一个功能，既保证计算密集作业的临时过载不会引起CPU超负荷。
CLR能将任务进行排序，并且控制任务启动数量，从而避免线程池超负荷。
阻塞是很很麻烦的，因为它会让CLR错误地人为它占用了大量CPU。CLR能检测并补偿（往池中注入更多线程），但这可能使线程池受到后续超负荷的影响。此外，这样会增加延迟，一位内CLR会限制注入新线程的速度，特别是应用程序生命周期的前期。
如果想提高CPU利用率，那么一定要报保证线程池整洁性。