23C#线程基础知识2
线程安全
本地状态(Local)和共享状态(Shared)
Local本地独立：
CLR为每个线程分配自己的内存栈，以便使本地变量保持独立。
static void Main(string[] args)
{
new Thread(Go).Start();//在分线程上 调用Go()
Go();//在main线程上 调用Go()
Console.ReadKey();
}
public static void Go()
{
//cycles是本地变量，在每个线程的内存栈上，都会创建cycles独立的副本。(线程之间不共享数据)
for (int cycles = 0; cycles < 5; cycles++)
{
Console.WriteLine("?");
}
}
Shared共享：
如果多个线程都引用到同一个对象实例，那么它们就共享了数据。
被lambda表达式或匿名委托所捕获的本地变量，会被编译器转化为字段，所以也会被共享。
静态字段也会在线程间共享。
下面的_done字段就是共享变量
class Program
{
private static bool _done;
static void Main(string[] args)
{
new Thread(Go).Start();
Go();
}
static void Go()
{
if (!_done)
{
_done = true;
Console.WriteLine("Done");
}
}
}
字段共享就会引出线程安全问题，因为上述例子的输出极有可能不是固定的，如果在_done = true;前加上Thread.Sleep()结果就会不一样。这样两个线程都同时进入了里面的判断了，因为一个线程还没有来得及修改_done的值，而另一个线程也拿到_done的值进入了该判断了。主线程和分线程是同时运行的。
class Program
{
private static bool _done;
static void Main(string[] args)
{
new Thread(Go).Start();
Go();
}
static void Go()
{
if (!_done)
{
Thread.Sleep(100);
_done = true;
Console.WriteLine("Done");
}
}
}
上例子就引出了线程安全这个关键概念(或者说缺乏线程安全)
上述例子的输出实际上是无法确定的:有可能（理论上)“Done”会被打印两次。如果交换Go方法里语句的顺序，那么“Done”被打印两次的几率会大大增加。因为一个线程可能正在评估 if，而另外一个线程在执行Thread.Sleep(100);语句，它还没来得及把done设置为true。所以，尽可能避免使用共享状态。
锁定与线程安全简介
Locking & Thread Safety
在读取和写入共享数据的时候，通过使用一个互斥锁（ exclusive lock )，就可以修复前面例子的问题。
C#里使用lock语句来加锁
当两个线程同时竞争一个锁的时候（锁可以基于任何引用类型对象），一个线程会等待或阻塞，直到锁变成可用状态。
如：
class Program
{
private static bool _done;
static readonly object _locker = new object();
static void Main(string[] args)
{
Thread t = new Thread(Go);
t.Start();//分线程调用
Go();//main线程调用
Console.ReadKey();
}
static void Go()
{
lock (_locker)
{
if (!_done)
{
Thread.Sleep(100);
_done = true;
Console.WriteLine("Done");
}
}
}
}
在这里使用lock将共享代码块包括，这个lock代码块就称为临界区，每次只允许一个线程进入，在多线程上下文中，以这种方式避免不确定性的代码就叫做线程安全。
互斥锁Lock不是线程安全的最好方法，很容易忘记对字段加锁，Lock也会引起一些问题(死锁)。
线程传参
①以直接使用lambda表达式做为Thread的参数
②可以使用Thread的Start方法来传递任务的参数，因为传参委托的类型是ThreadStart，所以参数必须是object类型。
class Program
{
static void Main(string[] args)
{
new Thread(G).Start("Hello World");
}
static void G(object str)
{
Console.WriteLine((string)str);
}
}
③使用lambda表达式可以很简单地给Thread传递参数。但是线程开始后，可能会不小心修改了被捕获地变量，比如下面的例子，每一次运行都有不同的输出，而且输出有可能会有相同的值。也就是lambda默认使用引用捕获，很有可能是线程运行时（非构造时，new Thread是构造但不一定立即运行）for循环已经将i递增到10了。i被lambda表达式捕获并被编译成字段，被所有线程共享。所以会有重复值。
for (int i = 0; i < 10; i++)
{
new Thread(() => Console.Write(i)).Start();
}
可以使用局部变量来解决这个问题，这个变量每次循环都会创建一个新的临时变量。也就是会创建10个内存地址。
for (int i = 0; i < 10; i++)
{
int temp = i;
new Thread(() => Console.Write(temp)).Start();
}
线程的执行是无序的，因为由操作系统的调度决定cpu运行哪条线程，所以打印也是无序的，但是绝对没有重复的值。
异常处理
创建线程时在作用范围内的 trylcatch/finally 块，在线程开始执行后就与线程无关了。
创建线程代码处的trycatch和线程里面的方法的异常捕获没关系。
static void Main(string[] args)
{
try
{
new Thread(Go).Start(); ;
}
catch (Exception ex)
{
Console.WriteLine("Exception!");
}
Console.ReadKey();
}
static void Go()
{
throw null;
}
解决方法，在线程里面捕获
static void Main(string[] args)
{
new Thread(Go).Start();
Console.ReadKey();
}
static void Go()
{
try
{
throw null;
}
catch (Exception ex)
{
Console.WriteLine("Exception!");
}
}
在WPF、WinForm里,可以订阅全局异常处理事件:
- Application.DispatcherUnhandledException
- Application.ThreadException
在通过消息循环调用的程序的任何部分发生未处理的异常（这相当于应用程序处于活动状态时在主线程上运行的所有代码）后，将触发这些异常。但是非U线程上的未处理异常，并不会触发它。
而任何线程有任何未处理的异常都会触发
AppDomain.CurrentDomain.UnhandledException
线程的优先级
线程的优先级（Priority属性）决定了相对于操作系统中其他活跃线程所占的执行时间。
如果想让某线程的优先级比其他进程中的线程高，那就必须提升进程的优先级，这里可以使用Process类
using (Process p = Process.GetCurrentProcess())
{
p.PriorityClass = ProcessPriorityClass.High;
}
但是，提高线程或进程的优先级可能会导致其他线程或线程处于饥饿状态，不能随便设置。
信号
有时，你需要让某个线程一直处于等待状态，直到接收到其他线程发来的通知，才解除等待状态，这就叫做signaling。最简单的信号结构是MaunalResetEvent类对象。
调用MaunalResetEvent类对象的WaitOne方法就会阻塞当前的线程，直到另一个线程通过调用Set方法来打开信号（发送信号）。
internal class Program
{
private static void Main(string[] args)
{
var signal = new ManualResetEvent(false);
var thread = new Thread(() =>
{
Console.WriteLine("Waiting for signal...");
//等待主线程发送的信号
signal.WaitOne();
signal.Dispose();
Console.WriteLine("Got signal!");
});
thread.Start();
Thread.Sleep(3000);
//向thread打开信号
signal.Set();
}
}
信号打开后可以通过Reset方法来重新关闭信号。
