一. Thread及其五大方法
Thread是.Net最早的多线程处理方式，它出现在.Net1.0时代，虽然现在已逐渐被微软所抛弃，微软强烈推荐使用Task(后面章节介绍)，但从多线程完整性的角度上来说，我们有必要了解下N年前多线程的是怎么处理的，以便体会.Net体系中多线程处理方式的进化。
Thread中有五大方法，分别是：Start、Suspend、Resume、Intterupt、Abort
①.Start：开启线程
②.Suspend：暂停线程
③.Resume：恢复暂停的线程
④.Intterupt：中断线程(会抛异常，提示线程中断)
⑤.Abort：销毁线程
这五大方法使用起来，也比较简单，下面贴一段代码，体会一下如何使用即可。
在这里补充一下，在该系列中，很多测试代码中看到TestThread0、TestThread、TestThread2，分别对应无参、一个参数、两个参数的耗时方法，代码如下：
/// <summary>
/// 执行动作:耗时而已
/// </summary>
private void TestThread0()
{
Console.WriteLine("线程开始：当前线程的id为:{0}，当前时间为：{1},", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"));
long sum = ;
for (int i = ; i < ; i++)
{
sum += i;
}
Console.WriteLine("线程结束：当前线程的id为::{0}，当前时间为：{1}", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"));
} /// <summary>
/// 执行动作:耗时而已
/// </summary>
private void TestThread(string threadName)
{
Console.WriteLine("线程开始：线程名为：{2}，当前线程的id为:{0}，当前时间为：{1},", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName);
long sum = ;
for (int i = ; i < ; i++)
{
sum += i;
}
Console.WriteLine("线程结束：线程名为：{2}，当前线程的id为::{0}，当前时间为：{1}", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName);
} /// <summary>
/// 执行动作:耗时而已
/// </summary>
private void TestThread2(string threadName1, string threadName2)
{
Console.WriteLine("线程开始：线程名为：{2}和{3}，当前线程的id为:{0}，当前时间为：{1},", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName1, threadName2);
long sum = ;
for (int i = ; i < ; i++)
{
sum += i;
}
Console.WriteLine("线程结束：线程名为：{2}和{3}，当前线程的id为::{0}，当前时间为：{1}", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName1, threadName2);
}
二. 从源码角度分析Thread类
(1) 分析Thread类的源码，发现其构造函数有两类，分别是ThreadStart和ParameterizedThreadStart类，
其中
①：ThreadStart类，是无参无返回值的委托。
②：ParameterizedThreadStart类,是有一个object类型参数但无返回值的委托.
使用方法：
①：针对ThreadStart类， ThreadStart myTs = () => TestThread(name); 然后再把myTs传入Thread的构造函数中
②：针对ParameterizedThreadStart类，ParameterizedThreadStart myTs = o => this.TestThread(o.ToString()); 然后再把myTs传入Thread的构造函数中
注：该方式存在拆箱和装箱的转换问题，不建议这么使用
通用写法：
Thread t = new Thread(() =>
{
Console.Write("333");
});
t.Start();
无须考虑Thread的构造函数,也不需要考虑Start的时候传参，直接使用()=>{}的形式，解决一切问题。
(二) 前台进程和后台进程（IsBackground属性）
①：前台进程,Thread默认为前台线程，程序关闭后，线程仍然继续，直到计算完为止
②：后台进程,将IsBackground属性设置为true，即为后台进程，主线程关闭，所有子线程无论运行完否，都马上关闭
(三) 线程等待（Join方法）
利用Join方法实现主线程等待子线程,当多个子线程进行等待的时候，只能通过for循环来实现
下面贴一下这三块设计到的代码：
private void button3_Click(object sender, EventArgs e)
{
Stopwatch watch = new Stopwatch();
watch.Start();
Console.WriteLine("-----------------Thread多线程 --------------------------");
Console.WriteLine("----------------- button_Click 开始 主线程id为：{0} --------------------------", Thread.CurrentThread.ManagedThreadId);
List<Thread> threadList = new List<Thread>();
for (int i = ; i < ; i++)
{
string name = string.Format("button1_Click{0}", i); #region 方式一
{
ThreadStart myTs = () => TestThread(name);
Thread myThread = new Thread(myTs);
//Thread默认为前台线程，程序关闭后，线程仍然继续，直到计算完为止
myThread.IsBackground = true; //设置为后台线程，主程序关闭所有线程均关闭
myThread.Start(); threadList.Add(myThread);
} #endregion #region 方式二
//{
// ParameterizedThreadStart myTs = o => this.TestThread(o.ToString());
// //ParameterizedThreadStart myTs = (o) =>
// //{
// // this.TestThread(o.ToString());
// //};
// Thread myThread = new Thread(myTs);
// myThread.Start(name); // threadList.Add(myThread);
//} #endregion
} #region Thread线程等待 //利用join方法进行线程等待
foreach (Thread thread in threadList)
{
thread.Join();
}
#endregion watch.Stop();
Console.WriteLine("----------------- button_Click 结束 主线程id为：{0} 总耗时：{1}--------------------------", Thread.CurrentThread.ManagedThreadId, watch.ElapsedMilliseconds); }
(四). 扩展：Thread实现线程回调
三. 数据槽-线程可见性
背景：为了解决多线程竞用共享资源的问题，引入数据槽的概念，即将数据存放到线程的环境块中，使该数据只能单一线程访问.（属于线程空间上的开销）
下面的三种方式是解决多线程竞用共享资源的通用方式：
①：AllocateNamedDataSlot命名槽位和AllocateDataSlot未命名槽位 解决线程竞用资源共享问题。
(PS:在主线程上设置槽位，使该数据只能被主线程读取，其它线程无法访问)
private void button10_Click(object sender, EventArgs e)
{
#region 01-AllocateNamedDataSlot命名槽位
{
var d = Thread.AllocateNamedDataSlot("userName");
//在主线程上设置槽位，使该数据只能被主线程读取，其它线程无法访问
Thread.SetData(d, "ypf");
//声明一个子线程
var t1 = new Thread(() =>
{
Console.WriteLine("子线程中读取数据：{0}", Thread.GetData(d));
});
t1.Start(); //主线程中读取数据
Console.WriteLine("主线程中读取数据：{0}", Thread.GetData(d));
} #endregion #region 02-AllocateDataSlot未命名槽位
{
var d = Thread.AllocateDataSlot();
//在主线程上设置槽位，使该数据只能被主线程读取，其它线程无法访问
Thread.SetData(d, "ypf");
//声明一个子线程
var t1 = new Thread(() =>
{
Console.WriteLine("子线程中读取数据：{0}", Thread.GetData(d));
});
t1.Start(); //主线程中读取数据
Console.WriteLine("主线程中读取数据：{0}", Thread.GetData(d)); }
#endregion }
②：利用特性[ThreadStatic] 解决线程竞用资源共享问题
(PS:在主线程中给ThreadStatic特性标注的变量赋值，则只有主线程能访问该变量)
③：利用ThreadLocal线程的本地存储， 解决线程竞用资源共享问题（线程可见性）
(PS: 在主线程中声明ThreadLocal变量，并对其赋值，则只有主线程能访问该变量)
四. 内存栅栏-线程共享资源
背景：当多个线程共享一个变量的时候，在Release模式的优化下，子线程会将共享变量加载的cup Cache中，导致主线程不能使用该变量而无法运行。
解决方案：
①：不要让多线程去操作同一个共享变量,从根本上解决这个问题。
②：利用MemoryBarrier方法进行处理,在此方法之前的内存写入都要及时从cpu cache中更新到 memory；在此方法之后的内存读取都要从memory中读取，而不是cpu cache。
③：利用VolatileRead/Write方法进行处理。
private void button11_Click(object sender, EventArgs e)
{
#region 01-默认情况(Release模式主线程不能正常运行)
//{
// var isStop = false;
// var t = new Thread(() =>
// {
// var isSuccess = false;
// while (!isStop)
// {
// isSuccess = !isSuccess;
// }
// Console.WriteLine("子线程执行成功");
// });
// t.Start(); // Thread.Sleep(1000);
// isStop = true; // t.Join();
// Console.WriteLine("主线程执行结束");
//}
#endregion #region 02-MemoryBarrier解决共享变量（Release模式下可以正常运行）
//{
// var isStop = false;
// var t = new Thread(() =>
// {
// var isSuccess = false;
// while (!isStop)
// {
// Thread.MemoryBarrier(); // isSuccess = !isSuccess;
// }
// Console.WriteLine("子线程执行成功");
// });
// t.Start(); // Thread.Sleep(1000);
// isStop = true; // t.Join();
// Console.WriteLine("主线程执行结束");
//}
#endregion #region 03-VolatileRead解决共享变量（Release模式下可以正常运行）
{
var isStop = ;
var t = new Thread(() =>
{
var isSuccess = false;
while (isStop == )
{
Thread.VolatileRead(ref isStop); isSuccess = !isSuccess;
}
Console.WriteLine("子线程执行成功");
});
t.Start(); Thread.Sleep();
isStop = ; t.Join();
Console.WriteLine("主线程执行结束");
}
#endregion }