我要评论1.使用多线程的几种方式
(1)不需要传递参数,也不需要返回参数
threadstart是一个委托，这个委托的定义为void threadstart()，没有参数与返回值。
class program
{
static void main(string[] args)
{
for (int i = 0; i < 30; i++)
{
threadstart threadstart = new threadstart(calculate);
thread thread = new thread(threadstart);
thread.start();
}
thread.sleep(2000);
console.read();
}
public static void calculate()
{
datetime time = datetime.now;//得到当前时间
random ra = new random();//随机数对象
thread.sleep(ra.next(10,100));//随机休眠一段时间
console.writeline(time.minute + ":" + time.millisecond);
}
}
(2)需要传递单个参数
parameterthreadstart委托定义为void parameterizedthreadstart(object state)，有一个参数但是没有返回值。
class program
{
static void main(string[] args)
{
for (int i = 0; i < 30; i++)
{
parameterizedthreadstart tstart = new parameterizedthreadstart(calculate);
thread thread = new thread(tstart);
thread.start(i*10+10);//传递参数
}
thread.sleep(2000);
console.read();
}
public static void calculate(object arg)
{
random ra = new random();//随机数对象
thread.sleep(ra.next(10, 100));//随机休眠一段时间
console.writeline(arg);
}
}
(3)使用专门的线程类(常用)
使用线程类可以有多个参数与多个返回值，十分灵活！
class program
{
static void main(string[] args)
{
mythread mt = new mythread(100);
threadstart threadstart = new threadstart(mt.calculate);
thread thread = new thread(threadstart);
thread.start();
//等待线程结束
while (thread.threadstate != threadstate.stopped)
{
thread.sleep(10);
}
console.writeline(mt.result);//打印返回值
console.read();
}
}
public class mythread//线程类
{
public int parame { set; get; }//参数
public int result { set; get; }//返回值
//构造函数
public mythread(int parame)
{
this.parame = parame;
}
//线程执行方法
public void calculate()
{
random ra = new random();//随机数对象
thread.sleep(ra.next(10, 100));//随机休眠一段时间
console.writeline(this.parame);
this.result = this.parame * ra.next(10, 100);
}
}
(4)使用匿名方法(常用)
使用匿名方法启动线程可以有多个参数和返回值，而且使用非常方便！
class program
{
static void main(string[] args)
{
int parame = 100;//当做参数
int result = 0;//当做返回值
//匿名方法
threadstart threadstart = new threadstart(delegate()
{
random ra = new random();//随机数对象
thread.sleep(ra.next(10, 100));//随机休眠一段时间
console.writeline(parame);//输出参数
result = parame * ra.next(10, 100);//计算返回值
});
thread thread = new thread(threadstart);
thread.start();//多线程启动匿名方法
//等待线程结束
while (thread.threadstate != threadstate.stopped)
{
thread.sleep(10);
}
console.writeline(result);//打印返回值
console.read();
}
}
(5)使用委托开启多线程(多线程深入)
1、用委托(delegate)的begininvoke和endinvoke方法操作线程
begininvoke方法可以使用线程异步地执行委托所指向的方法。然后通过endinvoke方法获得方法的返回值（endinvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。
class program
{
private delegate int newtaskdelegate(int ms);
private static int newtask(int ms)
{
console.writeline("任务开始");
thread.sleep(ms);
random random = new random();
int n = random.next(10000);
console.writeline("任务完成");
return n;
}
static void main(string[] args)
{
newtaskdelegate task = newtask;
iasyncresult asyncresult = task.begininvoke(2000, null, null);
//endinvoke方法将被阻塞2秒
int result = task.endinvoke(asyncresult);
console.writeline(result);
console.read();
}
}
2、使用iasyncresult.iscompleted属性来判断异步调用是否完成
class program
{
private delegate int newtaskdelegate(int ms);
private static int newtask(int ms)
{
console.writeline("任务开始");
thread.sleep(ms);
random random = new random();
int n = random.next(10000);
console.writeline("任务完成");
return n;
}
static void main(string[] args)
{
newtaskdelegate task = newtask;
iasyncresult asyncresult = task.begininvoke(2000, null, null);
//等待异步执行完成
while (!asyncresult.iscompleted)
{
console.write("*");
thread.sleep(100);
}
// 由于异步调用已经完成，因此， endinvoke会立刻返回结果
int result = task.endinvoke(asyncresult);
console.writeline(result);
console.read();
}
}
3、使用waitone方法等待异步方法执行完成
waitone的第一个参数表示要等待的毫秒数，在指定时间之内，waitone方法将一直等待，直到异步调用完成，并发出通知，waitone方法才返回true。当等待指定时间之后，异步调用仍未完成，waitone方法返回false，如果指定时间为0，表示不等待，如果为-1，表示永远等待，直到异步调用完成。
class program
{
private delegate int newtaskdelegate(int ms);
private static int newtask(int ms)
{
console.writeline("任务开始");
thread.sleep(ms);
random random = new random();
int n = random.next(10000);
console.writeline("任务完成");
return n;
}
static void main(string[] args)
{
newtaskdelegate task = newtask;
iasyncresult asyncresult = task.begininvoke(2000, null, null);
//等待异步执行完成
while (!asyncresult.asyncwaithandle.waitone(100, false))
{
console.write("*");
}
int result = task.endinvoke(asyncresult);
console.writeline(result);
console.read();
}
}
4、使用回调方式返回结果
要注意的是“my.begininvoke(3,300, methodcompleted, my)”，begininvoke方法的参数传递方式：
前面一部分(3,300)是其委托本身的参数。
倒数第二个参数(methodcompleted)是回调方法委托类型，他是回调方法的委托，此委托没有返回值，有一个iasyncresult类型的参数，当method方法执行完后，系统会自动调用methodcompleted方法。
最后一个参数(my)需要向methodcompleted方法中传递一些值，一般可以传递被调用方法的委托，这个值可以使用iasyncresult.asyncstate属性获得。
class program
{
private delegate int mymethod(int second, int millisecond);
//线程执行方法
private static int method(int second, int millisecond)
{
console.writeline("线程休眠" + (second * 1000 + millisecond) + "毫秒");
thread.sleep(second * 1000 + millisecond);
random random = new random();
return random.next(10000);
}
//回调方法
private static void methodcompleted(iasyncresult asyncresult)
{
if (asyncresult == null || asyncresult.asyncstate == null)
{
console.writeline("回调失败！！！");
return;
}
int result = (asyncresult.asyncstate as mymethod).endinvoke(asyncresult);
console.writeline("任务完成，结果：" + result);
}
static void main(string[] args)
{
mymethod my = method;
iasyncresult asyncresult = my.begininvoke(3,300, methodcompleted, my);
console.writeline("任务开始");
console.read();
}
}
5、其他组件的beginxxx和endxxx方法
在其他的.net组件中也有类似begininvoke和endinvoke的方法，如system.net.httpwebrequest类的begingetresponse和endgetresponse方法。其使用方法类似于委托类型的begininvoke和endinvoke方法，例如：
class program
{
//回调函数
private static void requestcompleted(iasyncresult asyncresult)
{
if (asyncresult == null || asyncresult.asyncstate==null)
{
console.writeline("回调失败");
return;
}
httpwebrequest hwr = asyncresult.asyncstate as httpwebrequest;
httpwebresponse response = (httpwebresponse)hwr.endgetresponse(asyncresult);
streamreader sr = new streamreader(response.getresponsestream());
string str = sr.readtoend();
console.writeline("返回流长度："+str.length);
}
static void main(string[] args)
{
httpwebrequest request =
(httpwebrequest)webrequest.create("http://www.baidu.com");
//异步请求
iasyncresult asyncresult = request.begingetresponse(requestcompleted, request);
console.writeline("任务开始");
console.read();
}
}
2.线程的状态控制
(1)前台线程与后台线程
thread.isbackground属性为true则是后台线程，为false则是前台线程。后台线程与前台线程区别如下：
a.当在主线程中创建了一个线程，那么该线程的isbackground默认是设置为false的。
b.当主线程退出的时候，isbackground=false的线程还会继续执行下去，直到线程执行结束。只有isbackground=true的线程才会随着主线程的退出而退出。
c.当初始化一个线程，把thread.isbackground=true的时候，指示该线程为后台线程。后台线程将会随着主线程的退出而退出。
d.原理：只要所有前台线程都终止后，clr就会对每一个活在的后台线程调用abort()来彻底终止应用程序
(2)由线程类(thread)启动动的线程状态控制
使用system.threading.threadstate与system.diagnostics.threadstate枚举判断线程状态，与thread.threadstate 属性配合使用。
system.threading.threadstate枚举状态：
system.diagnostics.threadstate枚举状态：
注意：您的代码在任何情况下都不应使用线程状态来同步线程的活动。
(3)由委托启动的线程的状态控制
委托的endinvoke方法阻止当前线程运行，直到委托异步执行完成。
iasyncresult.iscompleted属性表示委托异步执行是否完成。
委托的waitone方法等待异步方法执行完成。
3.多线程访问gui界面的处理
(1)多线程在gui编程时出现的问题
在gui编程时，如果你从非创建这个控件的线程中访问这个控件或者操作这个控件的话就会抛出这个异常。这是微软为了保证线程安全以及提高代码的效率所做的改进，但是也给大家带来很多不便。
(2)通过设置处理
设置system.windows.forms.control.checkforillegalcrossthreadcalls = false;在你的程序初始化的时候设置了这个属性，而且在你的控件中使用的都是微软framework类库中的控件的话，系统就不会再抛出你上面所说的这个错误了。
(3)通过委托处理(建议使用)
//按钮事件
private void button1_click(object sender, eventargs e)
{
thread thread = new thread(flush);
thread.isbackground = true;//设置成后台线程
thread.start();
}
//线程执行的方法
private void flush()
{
//定义委托
action action = delegate()
{
this.textbox1.appendtext(datetime.now.tostring() + "\r\n");
};
while (true)
{
//判断能否到当前线程操作该组件
if (this.textbox1.invokerequired)
{
//不在当前线程上操作
this.textbox1.invoke(action);//调用委托
}
else
{
//在当前线程上操作
this.textbox1.appendtext(datetime.now.tostring() + "\r\n");
}
thread.sleep(1000);
}
注意：使用该方式不会有无响应的情况发生，强烈建议使用该方式。此方式不会发生界面无响应的关键点：调用this.textbox1.invoke(action)就是在拥有this.textbox1对象的线程(不一定是当前线程，多数是主线程)上调用action委托，若action委托指向的方法执行时间过长就会使得界面无响应！而该方式中action委托指向的方法执行时间极为短。
(4)调用控件的invoke和begininvoke方法的区别
在多线程编程中，我们经常要在工作线程中去更新界面显示，而在多线程中直接调用界面控件的方法是错误的做法，正确的做法是将工作线程中涉及更新界面的代码封装为一个方法，通过invoke或者begininvoke去调用，两者的区别就是invoke导致工作线程等待，而begininvoke则不会。
而所谓的“一面响应操作，一面添加节点”永远只能是相对的，使ui线程的负担不至于太大而以，因为界面的正确更新始终要通过ui线程去做，我们要做的事情是在工作线程中包揽大部分的运算，而将对纯粹的界面更新放到ui线程中去做，这样也就达到了减轻ui线程负担的目的了。
(5)application.doevents()调用消息处理程序
在耗时的循环的ui更新的方法中，插入application.doevents()，会使界面获得响应，application.doevents()会调用消息处理程序。
(6)使用backgroundworker组件
主要的事件及参数：
1.dowork—当执行backgroundworker.runworkerasync方法时会触发该事件，并且传递doworkeventargs参数;
2.progresschanged—操作处理中获得的处理状态变化，通过backgroundworker.reportprogress方法触发该事件，并且传递progresschangedeventargs,其中包含了处理的百分比,这个参数在ui界面上设置progressbar控件。
3.runworkercompleted—异步操作完成或中途终止会触发该事件。如果需要提前终止执行后台操作，可以调用backgroundworker.cancelasync方法。在处理dowork事件的函数中检测backgroundworker.cancellationpending属性是否为true，如果是true，则表示用户已经取消了异步调用，同时将doworkeventargs.cancel属性设为true(传递给处理dowork事件的函数的第二个参数)，这样当退出异步调用的时候，可以让处理runworkercompleted事件的函数知道是正常退出还是中途退出。
主要的方法：
1. backgroundworker.runworkerasync—“起动”异步调用的方法有两次重载runworkerasync(),runworkerasync(object argument)，第二个重载提供了一个参数，可以供异步调用使用。（如果有多个参数要传递怎么办，使用一个类来传递他们吧)。调用该方法后会触发dowork事件，并且为处理dowork事件的函数传递doworkeventarg参数，其中包含了runworkerasync传递的参数。在相应dowork的处理函数中就可以做具体的复杂操作。
2. backgroundworker.reportprogress—需要在一个冗长的操作中向用户不断反馈进度，这样的话就可以调用的reportprogress(int percent),在调用 reportprogress 方法时，触发progresschanged事件。提供一个在 0 到 100 之间的整数，它表示后台活动已完成的百分比。你也可以提供任何对象作为第二个参数，允许你给事件处理程序传递状态信息。作为传递到此过程的 progresschangedeventargs 参数属性，百分比和你自己的对象（如果提供的话）均要被传递到 progresschanged 事件处理程序。这些属性被分别命名为 progresspercentage 和 userstate，并且你的事件处理程序可以以任何需要的方式使用它们。(注意：只有在backgroundworker.workerreportsprogress属性被设置为true该方法才可用)。
3. backgroundworker.cancelasync—但需要退出异步调用的时候，就调用的这个方法。但是样还不够，因为它仅仅是将backgroudworker.cancellationpending属性设置为true。你需要在具体的异步调用处理的时候，不断检查backgroudworker.cancellationpending是否为true，如果是真的话就退出。(注意：只有在backgroundworker.workersupportscancellation属性被设置为true该方法才可用)。
//按钮事件
private void button1_click(object sender, eventargs e)
{
this.backgroundworker1.runworkerasync();//处理事务
}
//处理事务事件
private void backgroundworker1_dowork(object sender, doworkeventargs e)
{
//初始化进度条
this.progressbar1.maximum = 100;
this.progressbar1.minimum = 0;
//模拟事物处理
for (int i = 0; i < 100; i++)
{
thread.sleep(10);
//局部操作完成事件触发
this.backgroundworker1.reportprogress(i, null);
}
}
//局部操作完成时执行的方法
private void backgroundworker1_progresschanged(object sender, progresschangedeventargs e)
{
this.progressbar1.value = e.progresspercentage;//设置进度条值
}
//事物处理完成时触发
private void backgroundworker1_runworkercompleted(object sender,runworkercompletedeventargs e)
{
messagebox.show(null, "工作线程完成！", "提示");
}
4.线程池
(1)线程池的作用
许多时候,我们需要用多线程,但是又不希望线程的数量过多,这就是线程池的作用，.net为我们提供了现成的线程池threadpool。
(2)线程池的使用
class program
{
//线程方法
public static void threadproc(object i)
{
console.writeline(i.tostring());
thread.sleep(1000);
}
public static void main()
{
threadpool.setmaxthreads(3, 3);//设置线程池
for (int i = 0; i < 10; i++)
{
threadpool.queueuserworkitem(new waitcallback(threadproc), "线程" + i);
}
console.writeline("运行结束");
console.read();
}
}
每一个进程都有一个线程池,线程池的默认大小是25,我们可以通过setmaxthreads方法来设置其最大值。
注意：因为waitcallback委托的原型是void waitcallback(object state)，那没有办法，我们只能将多个参数封装到一个object中。
5.线程同步
(1)代码块同步(monitor与lock )
1、说明：
使用monitor类的使用与lock关键字的使用在实现原理上相同。
monitor.enter 方法：在指定对象上获取排他锁。
monitor.tryenter 方法：试图获取指定对象的排他锁。
monitor.exit 方法：释放指定对象上的排他锁。
monitor.wait 方法：释放对象上的锁并阻塞当前线程，直到它重新获取该锁。
monitor.pulse 方法：通知等待队列中的线程锁定对象状态的更改。
monitor.pulseall 方法：通知所有的等待线程对象状态的更改。
2、示例
class program
{
private int count = 0;
//线程执行方法
public void threadproc()
{
monitor.enter(this);
thread.sleep(200);
count++;
console.writeline(count);
monitor.exit(this);
//等同于
//lock (this)
//{
// thread.sleep(200);
// count++;
// console.writeline(count);
//}
}
public static void main()
{
program p = new program();
for (int i = 0; i < 100; i++)
{
thread t = new thread(p.threadproc);
t.start();
}
console.read();
}
}
(2)waithandle介绍
waithandle是一个抽象类，下面是从它继承来的几个类：
mutex：一个同步基元，也可用于进程间同步。
autoresetevent：通知正在等待的线程已发生事件。无法继承此类。
manualresetevent：通知一个或多个正在等待的线程已发生事件。无法继承此类。
waithandle的几个方法：
waitall：等待指定数组中的所有元素收到信号。
waitany：等待指定数组中的任一元素收到信号。
waitone：当在派生类中重写时，阻塞当前线程，直到当前的waithandle收到信号。
(3)使用mutex
1、使用mutex控制线程同步
class program
{
private static mutex mutex;
static void main(string[] args)
{
mutex = new mutex(false);
for (int i = 0; i < 10; i++)
{
thread thread = new thread(method);
thread.start("线程" + i);
}
console.writeline("主线程执行完毕");
console.readline();
}
//线程执行方法
private static void method(object o)
{
mutex.waitone();//等待信号
for (int i = 0; i < 3; i++)
{
thread.sleep(500);
console.writeline(o.tostring() + "循环" + i);
}
mutex.releasemutex();//释放信号
}
}
注意：对于waitall、waitany、waitone方法的使用请参考autoresetevent与manualresetevent。
2、使用mutex控制进程间的同步
class program
{
static void main(string[] args)
{
bool flag = false;
mutex mutex = new mutex(true, "test", out flag);
//第一个参数:true--给调用线程赋予互斥体的初始所属权
//第一个参数:互斥体的名称
//第三个参数:返回值,如果调用线程已被授予互斥体的初始所属权,则返回true
if (flag)
{
console.write("进程运行...");
}
else
{
console.write("这个进程正在运行!");
thread.sleep(5000);//线程挂起5秒钟
environment.exit(1);//退出程序
}
console.readline();
}
}
运行以上代码生成的应用程序第一个实例，会得到结果:进程运行...
保持第一个运行状态，运行第二个实例，得到结果:这个进程正在运行!
注意：以上代码中创建了一个mutex，从其参数的解释中得知，第一个调用线程将得到互斥体的初始所属权，如果不释放的话，其他的线程得不到互斥体所有权
(4)使用autoresetevent
1、使用waitall静态方法
理解autoresetevent.waitall(waits)静态方法：waitall静态方法就是阻塞当前线程，直到waits数组里的所有元素都调用set()方法发送信号，再继续执行当前线程。
class program
{
public static void main()
{
autoresetevent[] waits = new autoresetevent[10];
for (int i = 0; i < 10; i++)
{
int temp = i;
waits[temp] = new autoresetevent(false);
action thread = delegate()
{
//线程执行方法
console.writeline("线程：" + temp);
thread.sleep(1000);
waits[temp].set();//发送线程执行完毕信号
};
threadstart ts = new threadstart(thread);
thread t = new thread(ts);
t.start();
}
autoresetevent.waitall(waits);//等待waits中的所有对象发出信号
console.writeline("线程全部执行完毕！");
console.read();
}
}
2、使用waitany静态方法
理解autoresetevent.waitany(waits)静态方法：waitany静态方法就是阻塞当前线程，只要waits数组有一个元素调用set()方法发送信号，就继续执行当前线程。
class program
{
public static void main()
{
autoresetevent[] waits = new autoresetevent[10];
for (int i = 0; i < 10; i++)
{
waits[i] = new autoresetevent(false);//初始化waits
}
for (int i = 0; i < 10; i++)
{
int temp = i;
action thread = delegate()
{
if (temp > 0)
{
autoresetevent.waitany(waits);//等待上一个线程执行完毕
}
//线程执行方法
thread.sleep(1000);
waits[temp].set();//发送线程执行完毕信号
console.writeline("线程：" + temp+"执行完毕");
};
threadstart ts = new threadstart(thread);
thread t = new thread(ts);
t.start();
}
console.read();
}
}
3、使用waitone成员方法
理解wait.waitone()成员方法：waitone方法就是阻塞当前线程，只要wait对象调用了set()方法发送信号，就继续执行当前线程。
class program
{
public static void main()
{
autoresetevent wait = new autoresetevent(false);
for (int i = 0; i < 10; i++)
{
action thread = delegate()
{
//线程执行方法
thread.sleep(1000);
wait.set();//发送线程执行完毕信号
console.writeline("线程：" + i+"执行完毕");
};
threadstart ts = new threadstart(thread);
thread t = new thread(ts);
t.start();
wait.waitone();//等待调用 waits.set()
}
console.read();
}
}
(5)使用manualresetevent与autoresetevent的区别
1、manualresetevent与autoresetevent的相同点
对于waitall、waitany、waitone方法的使用manualresetevent与autoresetevent对象是没有区别的。
2、manualresetevent与autoresetevent的区别
但是对于set()方法autoresetevent只会给一个线程发送信号，而manualresetevent会给多个线程发送信号。在我们需要同步多个线程的时候，就只能采用manualresetevent了。至于深层次的原因是，autoresetevent在set()之后，会将线程状态自动置为false，而manualresetevent在set()后，线程的状态就变为true了，必须手动reset()之后，才会重新将线程置为false。这也就是为什么他们的名字一个为auto(自动)，一个为manual(手动)的原因。
class program
{
private static manualresetevent wait = new manualresetevent(false);
public static void main()
{
wait.set();//设置线程状态为允许执行
thread thread1 = new thread(method);
thread1.start("线程1");
thread.sleep(1000);//等待线程1执行
wait.reset();//必须手动复位线程状态，使状态为不允许执行
thread thread2 = new thread(method);
thread2.start("线程2");//线程2将会一直等待信号
console.writeline("主线程结束");
console.read();
}
//线程执行方法
private static void method(object o)
{
wait.waitone();//等待信号
console.writeline(o.tostring());
}
}
(6)使用interlocked进行原子操作
interlocked类为多个线程共享的变量提供原子操作。
原子操作：interlocked.increment()操作是一个原子操作，作用是:count++ 。原子操作，就是不能被更高等级中断抢夺优先的操作。由于操作系统大部分时间处于开中断状态，所以，一个程序在执行的时候可能被优先级更高的线程中断。而有些操作是不能被中断的，不然会出现无法还原的后果，这时候，这些操作就需要原子操作。就是不能被中断的操作。
class program
{
private static int count = 0;
static void main(string[] args)
{
for (int i = 0; i < 100; i++)
{
thread thread = new thread(method);
thread.start("线程" + i);
}
thread.sleep(1000 * 3);//休眠足够的时间等待所有线程执行完毕
console.writeline("操作后的结果：" + program.count);
console.readline();
}
//线程执行方法
private static void method(object o)
{
thread.sleep(500);
//原子操作，类似：program.count++
interlocked.increment(ref program.count);
//program.count++;//非原子操作
console.writeline(o.tostring());
}
}
(7)使用readerwriterlock
使用monitor或mutex进行同步控制的问题：由于独占访问模型不允许任何形式的并发访问，这样的效率总是不太高。许多时候，应用程序在访问资源时是进行读操作，写操作相对较少。为解决这一问题，c#提供了system.threading.readerwriterlock类以适应多用户读/单用户写的场景。该类可实现以下功能：如果资源未被写操作锁定，那么任何线程都可对该资源进行读操作锁定，并且对读操作锁数量没有限制，即多个线程可同时对该资源进行读操作锁定，以读取数据。如果资源未被添加任何读或写操作锁，那么一个且仅有一个线程可对该资源添加写操作锁定，以写入数据。简单的讲就是：读操作锁是共享锁，允许多个线程同时读取数据；写操作锁是独占锁，同一时刻，仅允许一个线程进行写操作。
readerwriterlock类：定义支持单个写线程和多个读线程的锁。
readerwriterlockslim类：表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。
class program
{
private static int count = 0;//资源
static readerwriterlock rwl = new readerwriterlock();//读、写操作锁
static void main(string[] args)
{
for (int i = 0; i < 10; i++)
{
thread thread = new thread(read);//读线程
thread.start("线程" + i);
}
for (int i = 0; i < 10; i++)
{
thread thread = new thread(write);//写线程
thread.start("--线程" + i);
}
console.readkey();
}
private static void read(object o)//读数据
{
rwl.acquirereaderlock(1000 * 20); //申请读操作锁，在20s内未获取读操作锁，则放弃
console.writeline(o.tostring() + "读取数据:" + program.count);
thread.sleep(500);
rwl.releasereaderlock();//释放读操作锁
}
private static void write(object o)//写数据
{
rwl.acquirewriterlock(1000 * 20);//申请写操作锁，在20s内未获取写操作锁，则放弃
thread.sleep(500);
console.writeline(o.tostring() + "写数据:" + (++program.count));
rwl.releasewriterlock();//释放写操作锁
}
}
(8)使用semaphore
semaphore类：限制可同时访问某一资源或资源池的线程数。
class program
{
private static semaphore semaphore = new semaphore(0, 5);//初始化信号量
static void main(string[] args)
{
for (int i = 0; i < 10; i++)
{
thread thread = new thread(method);
thread.start("线程" + i);
}
semaphore.release(2);//释放信号量2个
console.writeline("主线程运行完毕！");
console.read();
}
//线程执行方法
private static void method(object o)
{
semaphore.waitone();//等待信号量
thread.sleep(1000);
console.writeline(o.tostring());
semaphore.release();//释放信号量
}
}
其它的线程只有等到主线程释放才会执行，因为我给信号量计数器的初始值是0，所以其它线程在主线程释放前都会被阻塞。而后，我在主线程直接用release(2)函数将计数器置为2，所以2个线程可以同时得到执行。
注意：可以给信号量设置一个名称，这个名称是操作系统可见的，因此，可以使用这些信号量来协调跨进程边界的资源使用。
class program
{
static void main(string[] args)
{
//初始信号量5个，最多信号量10个
semaphore seamphore = new semaphore(5, 10, "test");
seamphore.waitone();//等待信号
console.writeline("获取信号量 1");
seamphore.waitone();//等待信号
console.writeline("获取信号量 2");
seamphore.waitone();//等待信号
console.writeline("获取信号量 3");
console.writeline("主线程运行完毕！");
console.read();
}
}
运行两个这样的程序，结果如下，在第二个运行的示例中，会将阻塞在第三个信号量上：
6.定时器timer
(1)常用的3个timer类
system.threading.timer 提供以指定的时间间隔执行方法的机制。无法继承此类。
system.timers.timer 在应用程序中生成定期事件。
system.windows.forms.timer 实现按用户定义的时间间隔引发事件的计时器。此计时器最宜用于windows窗体应用程序中，并且必须在窗口中使用。
(2)system.timers.timer的使用示例
class program
{
static void main(string[] args)
{
system.timers.timer t = new system.timers.timer(1000);//产生事件的时间间隔1s
t.elapsed += new elapsedeventhandler(method); //到达时间的时候执行事件
t.autoreset = true;//设置是执行一次（false）还是一直执行(true)
t.enabled = true;//是否执行system.timers.timer.elapsed事件
console.writeline("完成！");
console.read();
}
private static void method(object source,elapsedeventargs e)
{
console.writeline("时间："+e.signaltime);
}
}
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请 点击进行留言回复，万千网友为您解惑！
网友评论