线程
对于所有需要等待的操作，例如移动文件，数据库和网络访问都需要一定的时间，此时就可以启动一个新的线程，同时完成其他任务。一个进程的多个线程可以同时运行在单核CPU上 或多核CPU的不同内核上。
线程是程序中独立的指令流。在VS编辑器中输入代码的时候，系统会分析代码，用下划线标注遗漏的分号和其他语法错误，这就是用一个后台线程完成。Word文档需要一个线程等待用户输入，另一个线程进行后台搜索，第三个线程将写入的数据存储在临时文件中。运行在服务器上的应用程序中等待客户请求的线程成为侦听器线程。
进程包含资源，如Window句柄，文件系统句柄或其他内核对象。每个进程都分配的虚拟内存。一个进程至少包含一个线程。
一个应用程序启动，会启动一个进程（应用程序运行的载体），然后进程启动多个线程。
程序 - > 进程 - > 线程
程序（我们写的代码 - 静态概念）
进程 -> 正在进行中的程序（正在运行的）
进程是操作系统启动起来
线程是在进程中启动起来
异步委托
创建线程的一种简单方式是定义一个委托,并异步调用它。 委托是方法的类型安全的引用。 Delegate类还支持异步地调用方法。在后台,Delegate类会创建一个执行任务的线程。接下来定义一个方法，使用委托异步调用（开启一个线程去执行这个方法）
static int TakesAWhile(int data, int ms)
{
Console.WriteLine("Takes a while Started!");
Thread.Sleep(ms);//程序运行到这里的时候会暂停ms毫秒，然后继续运行下一语句
Console.WriteLine("Takes a while Completed!");
return ++data;
}
public delegate int TakesAWhileDelegate(int data, int ms);//声明委托
static void Main()
{
TakesAWhileDelegate d1 = TakesAWhile;
IAsyncResult ar = d1.BeginInvoke(1, 3000, null, null);
while(ar.IsCompleted==false)
{
Console.Write(".");
Thread.Sleep(50);
}
int result = d1.EndInvoke(ar);
Console.WriteLine("Res:" + result);
Console.ReadKey();
}等待句柄IAsyncResult.AsyncWaitHandle
当我们通过BeginInvoke开启一个异步委托的时候，返回的结果是IAsyncResult，我们可以通过它的AsyncWaitHandle属性访问等待句柄。这个属性返回一个WaitHandler类型的对象，它中的WaitOne（）方法可以等待委托线程完成其任务，WaitOne方法可以设置一个超时时间作为参数（要等待的最长时间），如果发生超时就返回false。
static void Main()
{
TakesAWhileDelegate d1 = TakesAWhile;
IAsyncResult ar = d1.BeginInvoke(1, 3000, null, null);
while(true)
{
Console.Write(".");
if(ar.AsyncWaitHandle.WaitOne(50,false))
{
Console.WriteLine("Can get result now");
break;
}
}
int result = d1.EndInvoke(ar);
Console.WriteLine("Res:" + result);异步回调-回调方法
等待委托的结果的第3种方式是使用异步回调。在BeginInvoke的第三个参数中，可以传递一个满足AsyncCallback委托的方法，AsyncCallback委托定义了一个IAsyncResult类型的参数，其返回类型是void。对于最后一个参数，可以传递任意对象，以便从回调方法中访问它。（我们可以设置为委托实例，这样就可以在回调方法中获取委托方法的结果）
static void Main(){
TakesAWhileDelegate d1 = TakesAWhile;
d1.BeginInvoke(1,3000,TakesAWhileCompleted,d1);
while(true){
Console.Write(".");
Thread.Sleep(50);
}
}
static void TakesAWhileCompleted(IAsyncResult ar){//回调方法是从委托线程中调用
的，并不是从主线程调用的，可以认为是委托线程最后要执行的程序
if(ar==null) throw new ArgumentNullException("ar");
TakesAWhileDelegate d1 = ar.AsyncState as TakesAWhileDelegate;
int result = d1.EndInvoke(ar);
Console.Write("Res:"+result);
}
异步回调-Lambda表达式
等待委托的结果的第3种方式是使用异步回调。在BeginInvoke的第三个参数中，可以传递一个满足AsyncCallback委托的方法，AsyncCallback委托定义了一个IAsyncResult类型的参数，其返回类型是void。对于最后一个参数，可以传递任意对象，以便从回调方法中访问它。 （我们可以设置为委托实例，这样就可以在回调方法中获取委托方法的结果）
static void Main(){
TakesAWhileDelegate d1 = TakesAWhile;
d1.BeginInvoke(1,3000,ar=>{
int result = d1.EndInvoke(ar);
Console.WriteLine("Res:"+result);
},null);
while(true){
Console.Write(".");
Thread.Sleep(50);
}
}Thread类
使用Thread类可以创建和控制线程。Thread构造函数的参数是一个无参无返回值的委托类型。
static void ThreadMain()
{
Console.WriteLine("Running in a thread.");
}
static void Main(string[] args)
{
var t1 = new Thread(ThreadMain);
t1.Start();
Console.WriteLine("This is the main thread.");
}在这里哪个先输出是无法保证了线程的执行有操作系统决定，只能知道Main线程和分支线程是同步执行的。在这里给Thread传递一个方法，调用Thread的Start方法，就会开启一个线程去执行，传递的方法。
Thread类-Lambda表达式
上面直接给Thread传递了一个方法，其实也可以传递一个Lambda表达式。(委托参数的地方都可以使用Lambda表达式)
static void ThreadMain()
{
Console.WriteLine("Running in a thread.");
}
static void Main(string[] args)
{
//var t1 = new Thread(ThreadMain);
var t1 = new Thread(() => Console.WriteLine("Running in a thread,id:" + Thread.CurrentThread.ManagedThreadId));
t1.Start();
Console.WriteLine("This is the main thread.ID:"+Thread.CurrentThread.ManagedThreadId);
}给线程传递数据-通过Start
给线程传递一些数据可以采用两种方式，一种方式是使用Start，一种方式是创建一个自定义的类，把线程的方法定义为实例方法，这样就可以初始化实例的数据，之后启动线程。
//声明一个结构体用来传递数据
public struct Data
{
public string Message;
}
class Test2
{
static void ThreadMainWithParameters(object o)
{
Data d = (Data)o;
Console.WriteLine("Running in a thread,received:" + d.Message);
}
static void Main()
{
var d = new Data { Message = "Info" };
var t2 = new Thread(ThreadMainWithParameters);
t2.Start(d);
}
}给线程传递数据-自定义类
//给线程传递数据--自定义类
public class MyThread
{
private string data;
public MyThread(string data)
{
this.data = data;
}
public void ThreadMain()
{
Console.WriteLine("Running in a thread,data:" + data);
}
static void Main(string[] args)
{
var obj = new MyThread("info");
var t3 = new Thread(obj.ThreadMain);
t3.Start();
}
}后台线程和前台线程
只有一个前台线程在运行，应用程序的进程就在运行，如果多个前台线程在运行，但是Main 方法结束了，应用程序的进程仍然是运行的，直到所有的前台线程完成其任务为止。 在默认情况下，用Thread类创建的线程是前台线程。线程池中的线程总是后台线程。 在用Thread类创建线程的时候，可以设置IsBackground属性，表示它是一个前台线程还是一 个后台线程。
看下面例子中前台线程和后台线程的区别：
static void ThreadMain()
{
Console.WriteLine("Thread+" + Thread.CurrentThread.Name + "started");
Thread.Sleep(3000);
Console.WriteLine("Thread+" + Thread.CurrentThread.Name + "started");
}
static void Main()
{
var t1 = new Thread(ThreadMain) { IsBackground = false };
t1.Start();
Console.WriteLine("Main thread ending now.");
}后台线程用的地方：如果关闭Word应用程序，拼写检查器继续运行就没有意义了，在关闭应用程序的时候，拼写检查线程就可以关闭。 当所有的前台线程运行完毕，如果还有后台线程运行的话，所有的后台线程会被终止掉。
线程的优先级
线程有操作系统调度，一个CPU同一时间只能做一件事情（运行一个线程中的计算任务），当有很多线程需要CPU去执行的时候，线程调度器会根据线程的优先级去判断先去执行哪一个线程，如果优先级相同的话，就使用一个循环调度规则，逐个执行每个线程。 在Thead类中，可以设置Priority属性，以影响线程的基本优先级 ,Priority属性是一个ThreadPriority枚举定义的一个值。定义的级别有Highest ,AboveNormal,Normal,BelowNormal 和 Lowest。
控制线程
1. 获取线程的状态（Running还是Unstarted,,,），当我们通过调用Thread对象的Start方法，可以创建线程，但是调用了Start方法之后，新线程不是马上进入Running状态，而是出于Unstarted状态，只有当操作系统的线程调度器选择了要运行的线程，这个线程的状态才会修改为Running状态。我们使用Thread.Sleep()方法可以让当前线程休眠进入WaitSleepJoin状态；
2. 使用Thread对象的Abort()方法可以停止线程。调用这个方法，会在终止要终止的线程中抛出一个ThreadAbortException类型的异常，我们可以try catch这个异常，然后在线程结束前做一些清理的工作；
3. 如果需要等待线程的结束，可以调用Thread对象的Join方法，表示把Thread加入进来，停止当前线程，并把它设置为WaitSleepJoin状态，直到加入的线程完成为止。
线程池
创建线程需要时间。 如果有不同的小任务要完成,就可以事先创建许多线程 , 在应完成这些任务时发出请求。 这个线程数最好在需要更多的线程时增加,在需要释放资源时减少。 不需要自己创建线程池，系统已经有一个ThreadPool类管理线程。 这个类会在需要时增减 池中线程的线程数,直到达到最大的线程数。池中的最大线程数是可配置的。 在双核 CPU 中 ,默认设置为1023个工作线程和 1000个 I/o线程。也可以指定在创建线程池时应立即启动的最小线程数,以及线程池中可用的最大线程数。 如果有更多的作业要处理,线程池中线程的个数也到了极限,最新的作业就要排队,且必须等待线程完成其任务。
线程池示例：
static void JobForAThread(object state)
{
for(int i=0;i<3;i++)
{
Console.WriteLine("Loop " + i + " ,running in pooled thread" + Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(50);
}
}
static void Main()
{
int nWorkerThreads;
int nCompletionPortThreads;
ThreadPool.GetMaxThreads(out nWorkerThreads, out nCompletionPortThreads);
Console.WriteLine("Max worker threads:" + nWorkerThreads + " I/O completion threads:" + nCompletionPortThreads);
for(int i=0;i<5;i++)
{
ThreadPool.QueueUserWorkItem(JobForAThread);
}
Thread.Sleep(3000);
}示例应用程序首先要读取工作线程和 I/o线程的最大线程数,把这些信息写入控制台中。接着在 for循环中,调用ThreadPool.QueueUserWorkItem方法,传递一个WaitCallBack类型的委托 ,把 JobForAThread方法赋予线程池中的线程。 线程池收到这个请求后,就会从池中选择一个线程来调用该方法。如果线程池还没有运行,就会创建一个线程池,并启动第一个线程。 如果线程池己经在运行,且有一个空闲线程来完成该任务,就把该作业传递给这个线程。
使用线程池需要注意的事项：
1. 线程池中的所有线程都是后台线程；
2. 如果进程的所有前台线程都结束了,所有的后台线程就会停止；
3. 不能把入池的线程改为前台线程；
4. 不能给入池的线程设置优先级或名称；
5. 入池的线程只能用于时间较短的任务；
6. 如果线程要一直运行(如 Word的拼写检查器线程),就应使用Thread类创建一个线程。
任务
在.NET4 新的命名空间System.Threading.Tasks包含了类抽象出了线程功能，在后台使用的 ThreadPool进行管理的。任务表示应完成某个单元的工作。这个工作可以在单独的线程中运行，也可以 以同步方式启动一个任务。
任务也是异步编程中的一种实现方式。
启动任务
启动任务的三种方式：
TaskFactory tf=new TaskFactory();
Task t1=tf.StartNew(TaskMethod);
Task t2=TaskFactory.StartNew(TaskMethod);
Task t3=new Task(TaskMethod);
t3.Start();
我们创建任务的时候有一个枚举类型的选项TaskCreationOptions。
连续任务
如果一个任务t1的执行是依赖于另一个任务t2的，那么就需要在这个任务t2执行完毕后才开始执行t1。这个时候我们可以使用连续任务。
static void DoFirst()
{
Console.WriteLine("do in task: " + Task.CurrentId);
Thread.Sleep(3000);
}
static void DoSecond(Task t)
{
Console.WriteLine("task " + t.Id + " finished.");
Console.WriteLine("this task id is " + Task.CurrentId);
Thread.Sleep(3000);
}
static void Main(string[] args)
{
Task t1 = new Task(DoFirst);
Task t2 = t1.ContinueWith(DoSecond);
Task t3 = t1.ContinueWith(DoSecond);
Task t4 = t2.ContinueWith(DoSecond);
//Task t5 = t1.ContinueWith(DoError, TaskContinuationOptions.OnlyOnFaulted);
}任务层次结构
我们在一个任务中启动一个新的任务，相当于新的任务是当前任务的子任务，两个任务异步 执行，如果父任务执行完了但是子任务没有执行完，它的状态会设置为 WaitingForChildrenToComplete，只有子任务也执行完了，父任务的状态就变成 RunToCompletion
static void ChildTask()
{
Console.WriteLine("child");
Thread.Sleep(5000);
Console.WriteLine("child finished");
}
static void ParentTask()
{
Console.WriteLine("task id " + Task.CurrentId);
var child = new Task(ChildTask);
child.Start();
Thread.Sleep(1000);
Console.WriteLine("parent started child,parent end");
}
static void Main()
{
var parent = new Task(ParentTask);
parent.Start();
Thread.Sleep(2000);
Console.WriteLine(parent.Status);
Thread.Sleep(4000);
}线程问题-争用条件（资源访问冲突）
//线程问题-争用条件（资源访问冲突）
public class StateObject
{
private int state = 5;
public void ChangeState(int loop)
{
if (state == 5)
{
state++;
Console.WriteLine("State==5:" + state == 5 + " Loop:" + loop);
}
state = 5;
}
}
class Test8
{
static void RaceCondition(object o)
{
StateObject state = o as StateObject;
int i = 0;
while(true)
{
state.ChangeState(i++);
}
}
static void Main()
{
var state = new StateObject();
for(int i=0;i<20;i++)
{
new Task(RaceCondition, state).Start();
}
Thread.Sleep(10000);
}
}使用lock（锁）解决争用条件的问题：
static void RaceCondition(object o)
{
StateObject state = o as StateObject;
int i = 0;
while(true)
{
lock (state)
{
state.ChangeState(i++);
}
}
}另外一种方式是锁定StateObject中的state字段，但是我们的lock语句只能锁定个引用类型。因此可以定义一个object类型的变量sync，将它用于lock语句，每次修改state的值的时候，都使用这个一个sync的同步对象。就不会出现争用条件的问题了。下面是改进后的ChangeState方法：
private object sync = new object();
public void ChangeState(int loop)
{
lock(sync)
{
if (state == 5)
{
state++;
Console.WriteLine("State==5:" + state == 5 + " Loop:" + loop);
}
state = 5;
}
}线程问题-死锁
//线程问题——死锁
public class SampleThread
{
private StateObject s1;
private StateObject s2;
public SampleThread(StateObject s1,StateObject s2)
{
this.s1 = s1;
this.s2 = s2;
}
public void Deadlock1()
{
int i = 0;
while(true)
{
lock(s1)
{
lock(s2)
{
s1.ChangeState(i);
s2.ChangeState(i);
i++;
Console.WriteLine("Running i: " + i);
}
}
}
}
public void Deadlock2()
{
int i = 0;
while (true)
{
lock (s2)
{
lock (s1)
{
s1.ChangeState(i);
s2.ChangeState(i);
i++;
Console.WriteLine("Running i: " + i);
}
}
}
}
}
class Test9
{
static void Main()
{
var state1 = new StateObject();
var state2 = new StateObject();
new Task(new SampleThread(state1, state2).Deadlock1).Start();
new Task(new SampleThread(state1, state2).Deadlock2).Start();
}
}如何解决死锁？——> 在编程的开始设计阶段，设计锁定顺序。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
