//前台线程和后台线程唯一区别就是:应用程序必须运行完所有的前台线程才可以退出；
//而对于后台线程，应用程序则可以不考虑其是否已经运行完毕而直接退出，
//所有的后台线程在应用程序退出时都会自动结束。
通过匿名委托或Lambda表达式来为Thread的构造方法赋值
Thread thread3 = new Thread(delegate() { Console.WriteLine("匿名委托"); });
thread3.Start();
Thread thread4 = new Thread(( ) => { Console.WriteLine("Lambda表达式"); });
thread4.Start();
二、 定义一个线程类
我们可以将Thread类封装在一个MyThread类中，以使任何从MyThread继承的类都具有多线程能力。MyThread类的代码如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace MyThread
{
abstract class MyThread
{
Thread thread = null; abstract public void run(); public void start()
{
if (thread == null)
thread = new Thread(run);
thread.Start();
}
}
}
可以用下面的代码来使用MyThread类。
class NewThread : MyThread
{
override public void run()
{
Console.WriteLine("使用MyThread建立并运行线程");
}
} static void Main(string[] args)
{ NewThread nt = new NewThread();
nt.start();
}
如果使用在第二节定义的MyThread类，传递参数会显示更简单，代码如下：
class NewThread : MyThread
{
private String p1;
private int p2;
public NewThread(String p1, int p2)
{
this.p1 = p1;
this.p2 = p2;
} override public void run()
{
Console.WriteLine(p1);
Console.WriteLine(p2);
}
} NewThread newThread = new NewThread("hello world", );
newThread.start();
EventWaitHandle（等待事件句柄）
EventWaitHandle是一个在线程处理上的类，它可以和WaitHandle配合使用完成多线程任务等待调度，并且在主线程中统一处理想要的结果。
private List<string> test()
{
List<string> list = new List<string>();
//创建等待事件句柄集合
var watis = new List<EventWaitHandle>();
for (int i = ; i < ; i++)
{
//创建句柄 true终止状态
var handler = new ManualResetEvent(false);
watis.Add(handler);
//将要执行的方法参数化
ParameterizedThreadStart start = new ParameterizedThreadStart(selectData);
//创建线程，传入线程参数
Thread t = new Thread(start);
//启动线程
t.Start(new Tuple<int, EventWaitHandle, List<string>>(i, handler,list));
}
//等待句柄
WaitHandle.WaitAll(watis.ToArray());
return list;
}
首先创建了一个EventWaitHandle的list，这个list将用于来添加所有的需要执行的等待事件句柄
然后将需要参与等待的任务（一个方法）参数化传入线程初始化的构造
在线程启动时，将与之对应的EventWaitHandle子类ManualResetEvent的对象传入需要调用的任务（方法）中
最后使用WaitHandle.WaitAll执行所有的等待事件句柄
private static void selectData(object param)
{
Tuple<int, EventWaitHandle,List<string>> t = (Tuple<int, EventWaitHandle,List<string>>)param;
Console.WriteLine(Thread.CurrentThread.Name + "执行开始");
//sleep线程，模拟查询业务
if (t.Item1 == )
{
Thread.Sleep();
t.Item3.Add("这是第0个线程添加的内容");
}
else if (t.Item1 == )
{
Thread.Sleep();
t.Item3.Add("这是第1个线程添加的内容");
}
else if (t.Item1 == )
{
Thread.Sleep();
t.Item3.Add("这是第2个线程添加的内容");
}
//将事件状态设置为有信号，从而允许一个或多个等待线程继续执行。
t.Item2.Set();
Console.WriteLine(Thread.CurrentThread.Name + "执行结束");
}
在等待句柄任务中执行查询，并将结果加入数据list中
最后在任务的最后（执行完成）将等待事件句柄对象Set(),这个方法将发出一个信号（暂时理解为通知WaitHandle当前的等待事件句柄执行完成）
作者：methodname
链接：https://www.jianshu.com/p/64670b155b1c
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
Lock锁
lock是一种比较好用的简单的线程同步方式，它是通过为给定对象获取互斥锁来实现同步的。它可以保证当一个线程在关键代码段的时候，另一个线程不会进来，它只能等待，等到那个线程对象被释放，也就是说线程出了临界区。
public void Function()
{
object lockThis = new object ();
lock (lockThis)
{
// Access thread-sensitive resources.
}
}
lock关键字的用法和用途。
using System;
using System.Threading;
namespace ThreadSimple
{
internal class Account
{
int balance; //余额
Random r=new Random();
internal Account(int initial)
{
balance=initial;
}
internal int Withdraw(int amount) //取回、取款
{
if(balance<)
{
//如果balance小于0则抛出异常
throw new Exception("NegativeBalance");//负的 余额
}
//下面的代码保证在当前线程修改balance的值完成之前
//不会有其他线程也执行这段代码来修改balance的值
//因此，balance的值是不可能小于0的
lock(this)
{
Console.WriteLine("CurrentThread:"+Thread.CurrentThread.Name);
//如果没有lock关键字的保护，那么可能在执行完if的条件判断(成立)之后
//另外一个线程却执行了balance=balance-amount修改了balance的值
//而这个修改对这个线程是不可见的，所以可能导致这时if的条件已经不成立了
//但是，这个线程却继续执行 balance=balance-amount，所以导致balance可能小于0
if(balance>=amount)
{
Thread.Sleep();
balance=balance-amount;
return amount;
} else
{
return ;
//transactionrejected
}
}
}
internal void DoTransactions()//取款事务
{
for (int i = ; i < ; i++)
{
Withdraw(r.Next(-, ));
}
}
} internal class Test
{
static internal Thread[] threads=new Thread[];
public static void Main()
{
Account acc=new Account();
for(int i=;i<;i++)
{
Thread t=new Thread(new ThreadStart(acc.DoTransactions));
threads[i]=t;
}
for (int i = ; i < ; i++)
{
threads[i].Name = i.ToString();
}
for (int i = ; i < ; i++)
{
threads[i].Start();
Console.ReadLine();
}
}
}
}