C#多线程学习一

一、概述:C#支持多线程并行执行程序,一个线程有他单独的执行路径,能够与其他线程同时执行,一个程序是由一个单线程开始,该单线程由CLR(公共语言运行时)和操作系统创建而成,并具有多线程创建额外线程的功能。

1、创建线程的方法

<1>、通过Thread类来创建线程,ThreadStart委托创建线程从哪里开始运行的方法

using System;
using System.Threading;
namespace Mulithreading{
class CreateThreadMethods{
static void Main(string[] args){
ThreadStart ts=new ThreadStart(Run);//创建指定线程从哪里(哪个方法)开始的委托
Thread th=new Thread(ts);//传入指定的委托,创建线程实例
th.Start();//开始线程

}
static void Run(){

}
}
}

<2>第二种方式:通过C#语法糖来创建线程,直接给Thread类传递方法,这个方法会被编译器自动推断出来,也就是说只要传递给Thread类的方法符合ThreadStart委托所定义的方法格式,那么这个方法会被编译器自动编译成ThreadStart委托

using System;
using System.Threading;
namespace Mulithreading{
class CreateThreadMethods{
static void Main(string[] args){
Thread th=new Thread(Run);
th.Start();
}
static void Run(){
}
}
}

<3>第三种方式:采用匿名委托的方式,创建线程

static void Main() {
Thread t = new Thread (delegate() { Console.WriteLine ("Hello!"); });
t.Start();
}

2、创建线程前需要注意的事项

<1>、线程有一个IsAlive属性，在调用Start()之后直到线程结束之前一直为true。一个线程一旦结束便不能重新开始了。

二、实例

1、主线程和子线程分别执行不同的任务

using System;
using System.Threading;
namespace MuliThreading
{
class Thread1
{
static void Main(string[] args)
{
Thread t = new Thread(writeY);   //为该类传入一个方法(委托)
t.Start();
while (true) Console.Write("x");
}
static void writeY()
{
while (true) Console.Write("y");
}

//代码解读:主线程创建了一个新线程t,t传入的是writeY方法,重复打印y,同时主线程打印x,主线程和新线程同时执行

}
}

输出结果:


无限输出x和y;

2、主线程和子线程分别执行相同的任务

using System;
using System.Threading;

namespace Mulithreading
{
class Thread2
{
static void Main(string[] args) {
new Thread(Go).Start();
Go();
}
static void Go() {
for (int i = 0; i < 5; i++) {
Console.Write("?");
}
}
//代码解读:在主线程中创建了一个子线程,主线程和子线程同时执行Go()
}
}

输出:


3、主线程和子线程使用同一目标的公共实例

using System;
using System.Threading;

namespace Mulithreading
{
class Thread3
{
bool done;
static void Main(string[] args)
{
Thread3 t3 = new Thread3();
Thread t = new Thread(t3.Go);
t.Start();
t3.Go();

}
void Go() {
if (!done) { done = true; Console.Write("done"); }
}

//代码解读:主线程Main()方法和在其中定义的子线程所调用的GO()方法共享以一个公共属性done,当吊用子线程时,对done的修改会影响到主线程的使用,因为两个线程在理论上讲是同时执行,但是实际上不可能精确的同时执行,所以当主线程吊用Go()方法是done为true
}
}

输出:done

4、主线程和子线程使用同一目标属性可能会出现的问题

using System;
using System.Threading;
namespace Mulithreading
{
class Thread4
{
bool done;
static void Main(string[] args)
{
Thread4 t4 = new Thread4();
new Thread(t4.Go).Start();
t4.Go();
}
void Go()
{
if (!done) { Console.Write("done"); done = true; }
}
//代码解读:当在主线程中吊用子线程时,注意两个线程是同时进行的,所以当子线程吊用Go()方法并执行时,主线程也同时进行吊用执行,两个线程是并行的,所以他们同时输出了done
}
}

输出:done done

5、线程间共用同一静态变量产生的"线程安全问题"

using System;
using System.Threading;

namespace Mulithreading
{
class Thread5
{
//静态字段提供了另一种线程间共享数据的方法
static bool done;
static void Main(string[] args)
{
new Thread(Go).Start();
Go();
}
static void Go() {
if (!done) { done = true; Console.Write("done"); }
}
//代码解读:这个demo充分的说明了一个潜在的问题,"线程安全问题",从这这列子中看就是,无法确定输出的结果,有可能是输出两个"done"(虽然可能性不大),但是如果调正代码如下
//static void Go(){
//if(!done){Console.Write("done");done=true;}
//}
//这样打印两次done的概率就大大增大了

}
}

输出:done

6、使用排他锁(locker)解决线程安全问题

使用场景:在多线程编程中,会有多个线程并发吊用同一个代码块A的情况,用来提升代码的执行效率。在某些情况下,我们可能需要在执行代码块A的同时,同步地执行代码块B。即同一个时间段只有一个线程执行代码块B,这个时候就需要用到排他锁(lock),lock能确保代码块B完成运行的同时,保证不会被其他线程所干扰或中断。它可以把一段代码定义成为互斥段,互斥段在一个时刻内只允许一个线程进入,其他线程必须等待,下面是实例代码:

using System;
using System.Threading;
namespace Mulithreading
{
class Thread6
{
static bool done;
static Object locker = new Object();
static void Main(string[] args)
{
new Thread(Go).Start();
Go();
}
static void Go()
{
lock (locker)
{
if (!done) { Console.Write("done"); done = true; }
}
}
}
}

注意:

1、lock语句中的表达式一定要是引用类型的表达式,编译器永远不会为lock内的语句进行隐式装箱转换,当lock内的语句为值类型而不是引用类型时,则会报一个编译错误；

2、常用的引用类型有:类、接口、委托、字符串、object、数组。但是最好不要锁定字符串,因为使用lock进行同步时,要保证lock的是同一个对象,当我们对lock的字符串进行赋值(修改)是,实际上是创建了一个新的对象,这样多个线程以及每个循环之间所lock的对象都不同,这样达不到同步的效果,常用的方法是,new 一个Object,并且永不修改他。

using System;
using System.Threading;

namespace Mulithreading
{
class CastCoin
{
static Object locker = new Object();
public static int donationNums = 0;
static void Main(string[] args) {
new Thread(Write).Start();//先进
new Thread(Write).Start();//后进
}
static void Write() {
while (true)
{
lock (locker)
{
donationNums += 100;
Console.WriteLine("当前有人正在捐款......请稍等");
Thread.Sleep(3000);
Console.WriteLine("到目前为止,共募捐{0}元", donationNums);
}
}
}
}
}

代码解读:上面代码加了lock之后,一次只允许一个线程进入,所以输出结果如下图:



如果不加lock,结果如下图:



分析:两个线程同时执行累加100的操作,所以当输出总金额的时候,两个线程都执行完了累加100的操作,所以两个线程都输出200......以此类推;

7、使用Join方法,阻塞调用线程,直到子线程终止或者到一定的时间为止

Join一共有三个重载方法

public void Join();
public bool Join(int millisecondsTimeout);
public bool Join(TimeSpan timeout);

相信理解了一个,其他的就迎刃而解了。

首先说Join()方法,他是Thread类的一个实例方法,可惜的是我大MSDN对于Join()的注释也太简单了,下面的英文有看不懂,所以只能去问度娘了.

MSDN:在继续执行标准的 COM 和 SendMessage 消息泵处理期间，阻止调用线程，直到由该实例表示的线程终止。

度娘:直接上代码

using System;
using System.Threading;
using System.Diagnostics;
namespace Mulithreading{
class Thread_Join{
static void Main(string[] args){
Stopwatch sw=Stopwatch.StartNew();
Thread[] ths=new Thread[5];
Array.ForEach<Thread>(ths,t=>{
t=new Thread(new ThreadStart(Run));//开启一个新的时间间隔实例
t.Start();
t.Join();//阻塞主线程,直到线程数组执行完毕才会执行主线程中的方法
});
Console.Write("总共花费时间:{0}",sw.Elapsed);
}
static void Run(){
Thread.Sleep(1000);
}
}
}

输出:


推论:根据结果可以推断线程数组依次去执行Run()方法,如果不是依次,那么输出结果就会是1秒。而且t.Join让子线程依次执行Run()方法的同时,也阻塞了主线程。

综上所述:也就是主线程执行子线程数组,子线程数组在Join()方法的影响下,子线程数组中的子线程不会并发的一次性全部执行完毕,而是一个个依次执行,而主线程(这里是Main()方法),只有当子线程数组全部执行完毕,才会执行主线程中的方法;

下面我们通过代码来证明这一推论:

using System;
using System.Threading;
using System.Diagnostics;
namespace Mulithreading
{
class Thread_Join
{
static void Main(string[] args)
{
Stopwatch sw = Stopwatch.StartNew();
Thread[] ths = new Thread[5];
int i = 0;
Array.ForEach<Thread>(ths, t =>
{
t = new Thread(new ThreadStart(Run));
t.Start();
i++;
t.Name = "线程" + i;  //给当前线程命名
t.Join();
});
Console.WriteLine("总共花费时间:{0}", sw.Elapsed);
sw.Stop();
}
static void Run()
{
Thread.Sleep(1000);
Console.WriteLine("当前正在执行的线程:{0}", Thread.CurrentThread.Name);//输出正在执行该方法的线程名
}
}
}

通过给线程命名的方式,证明了我们的推论是正确的;

8、通过ParameterizedThreadStart委托给线程调用的方法传递参数来区分线程

using System;
using System.Threading;

namespace Mulithreading
{
class ParameterizedThreadStart_Study
{
static object locker = new object();
static void Main() {
//由于ThreadStart只能接收无参数无返回值的方法,但是有些时候我们需要为线程吊用的方法传递对象,这个时候ThreadStart就无法完成这个工作
//所幸的是.Net Framework定义了另一个版本的委托叫做PatameterizedThreadStart,单从字面上看它的意思是:参数化的ThreadStart,它可以接收一个Object作为参数

ParameterizedThreadStart pt = new ParameterizedThreadStart(Run);//ParameterizedThreadStart接收一个方法(该方法无返回值,接收一个Object作为参数)
Thread th = new Thread(pt);
th.Start(true);
Run(false);

}
static void Run(object obj){
lock (locker)
{
if (obj != null)
Console.WriteLine((bool)obj == true ? "hello" : "HELLO");
else
Console.WriteLine("Run方法需要一个object参数");
}
}
}
}