C#多线程编程介绍——使用thread、threadpool、timer

2021-12-10 22:15:28

在system.threading 命名空间提供一些使得能进行多线程编程的类和接口，其中线程的创建有以下三种方法：thread、threadpool、timer。下面我就他们的使用方法逐个作一简单介绍。
1． thread
这也许是最复杂的方法，但他提供了对线程的各种灵活控制。首先你必须使用他的构造函数创建一个线程实例，他的参数比较简单，只有一个threadstart 委托：
public thread(threadstart start);

然后调用start（）启动他，当然你能利用他的priority属性来设置或获得他的运行优先级（enum threadpriority： normal、 lowest、 highest、 belownormal、 abovenormal）。

见下例：他首先生成了两个线程实例t1和t2，然后分别设置他们的优先级，接着启动两线程（两线程基本相同，只不过他们输出不相同，t1为“1”，t2为“2”，根据他们各自输出字符个数比可大致看出他们占用cpu时间之比,这也反映出了他们各自的优先级）。

static void main(string[] args)
{
thread t1 = new thread(new threadstart(thread1));
thread t2 = new thread(new threadstart(thread2));
t1.priority = threadpriority.belownormal ;
t2.priority = threadpriority.lowest ;
t1.start();
t2.start();
}
public static void thread1()
{
for (int i = 1; i < 1000; i++)
{//每运行一个循环就写一个“1”
dosth();
console.write("1");
}
}
public static void thread2()
{
for (int i = 0; i < 1000; i++)
{//每运行一个循环就写一个“2”
dosth();
console.write("2");
}
}
public static void dosth()
{//用来模拟复杂运算
for (int j = 0; j < 10000000; j++)
{
int a=15;
aa = a*a*a*a;
}
}

以上程式运行结果为：

11111111111111111111111111111111111111111121111111111111111111111111111111111111111112

从以上结果我们能看出，t1线程所占用cpu的时间远比t2的多，这是因为t1的优先级比t2的高，若我们把t1和t2的优先级都设为normal，那结果是怎么？他们所占用的cpu时间会相同吗？是的，正如你所料，见下图：

121211221212121212121212121212121212121212121212121212121212121212121

212121212121212121212121212121212121212121212121212121212121212121212

121212121212121212

从上例我们可看出，他的构造类似于win32的工作线程，但更加简单，只需把线程要调用的函数作为委托，然后把委托作为参数构造线程实例即可。当调用start()启动后，便会调用相应的函数，从那函数第一行开始执行。
接下来我们结合线程的threadstate属性来了解线程的控制。

threadstate是个枚举类型，他反映的是线程所处的状态。

当一个thread实例刚创建时，他的threadstate是unstarted；当此线程被调用start()启动之后，他的threadstate是 running; 在此线程启动之后，如果想让他暂停（阻塞），能调用thread.sleep() 方法，他有两个重载方法（sleep(int )、sleep(timespan )），只不过是表示时间量的格式不同而已，当在某线程内调用此函数时，他表示此线程将阻塞一段时间（时间是由传递给 sleep 的毫秒数或timespan决定的，但若参数为0则表示挂起此线程以使其他线程能够执行，指定 infinite 以无限期阻塞线程），此时他的threadstate将变为waitsleepjoin，另外值得注意一点的是sleep()函数被定义为了static？! 这也意味着他不能和某个线程实例结合起来用，也即不存在类似于t1.sleep(10)的调用！正是如此，sleep()函数只能由需“sleep”的线程自己调用，不允许其他线程调用，正如when to sleep是个人私事不能由他人决定。不过当某线程处于waitsleepjoin状态而又不得不唤醒他时，可使用thread.interrupt 方法 ，他将在线程上引发threadinterruptedexception，下面我们先看一个例子（注意sleep的调用方法）：

static void main(string[] args)
{
thread t1 = new thread(new threadstart(thread1));
t1.start();
t1.interrupt ();
e.waitone ();
t1.interrupt ();
t1.join();
console.writeline(“t1 is end”);
}
static autoresetevent e = new autoresetevent(false);
public static void thread1()
{
try
{//从参数可看出将导致休眠
thread.sleep(timeout.infinite);
}
catch(system.threading.threadinterruptedexception e)
{//中断处理程式
console.writeline (" 1st interrupt");
}
e.set ();
try
{// 休眠
thread.sleep(timeout.infinite );
}
catch(system.threading.threadinterruptedexception e)
{
console.writeline (" 2nd interrupt");
}//暂停10秒
thread.sleep (10000);
}

运行结果为： 1st interrupt
2nd interrupt
(10s后)t1 is end
从上例我们能看出thread.interrupt方法能把程式从某个阻塞（waitsleepjoin）状态唤醒进入对应的中断处理程式，然后继续往下执行（他的threadstate也变为running），此函数的使用必须注意以下几点：
1 .此方法不仅可唤醒由sleep导致的阻塞，而且对一切可导致线程进入waitsleepjoin状态的方法(如wait和join)都有效。如上例所示, 使用时要把导致线程阻塞的方法放入try块内，并把相应的中断处理程式放入catch块内。
2 .对某一线程调用interrupt, 如他正处于waitsleepjoin状态, 则进入相应的中断处理程式执行，若此时他不处于waitsleepjoin状态，则他后来进入此状态时，将被即时中断。若在中断前调用几次interrupt，只有第一次调用有效, 这正是上例我用同步的原因，这样才能确保第二次调用interrupt在第一个中断后调用，否则的话可能导致第二次调用无效（若他在第一个中断前调用）。你能把同步去掉试试，其结果非常可能是： 1st interrupt

上例还用了另外两个使线程进入waitsleepjoin状态的方法：利用同步对象和thread.join方法。join方法的使用比较简单，他表示在调用此方法的当前线程阻塞直至另一线程（此例中是t1）终止或经过了指定的时间为止(若他还带了时间量参数)，当两个条件（若有）任一出现，他即时结束waitsleepjoin状态进入running状态(可根据.join方法的返回值判断为何种条件，为true，则是线程终止;false则是时间到)。
线程的暂停还可用thread.suspend方法，当某线程处于running状态时对他调用suspend方法，他将进入suspendrequested状态，但他并不会被即时挂起，直到线程到达安全点之后他才能将该线程挂起，此时他将进入suspended状态。如对一个已处于suspended的线程调用则无效，要恢复运行只需调用thread.resume即可。
线程的销毁，对需销毁的线程调用abort方法，他会在此线程上引发threadabortexception。我们可把线程内的一些代码放入try块内，并把相应处理代码放入相应的catch块内，当线程正执行try块内代码时如被调用abort，他便会跳入相应的catch块内执行，执行完catch快内的代码后他将终止（若catch块内执行了resetabort则不同了：他将取消当前abort请求，继续向下执行。所以如要确保某线程终止的最佳用join，如上例）。
2． threadpool
提供一个线程池，该线程池可用于发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。

线程池（threadpool）是一种相对较简单的方法，他适应于一些需要多个线程而又较短任务（如一些常处于阻塞状态的线程），他的缺点是对创建的线程不能加以控制，也不能设置其优先级。由于每个进程只有一个线程池，当然每个应用程式域也只有一个线程池（对线），所以你将发现threadpool类的成员函数都为static！当你首次调用threadpool.queueuserworkitem、threadpool.registerwaitforsingleobject等，便会创建线程池实例。

下面我就线程池当中的两函数作一介绍：

public static bool queueuserworkitem( //调用成功则返回true
waitcallback callback,//要创建的线程调用的委托
object state //传递给委托的参数
)//他的另一个重载函数类似,只是委托不带参数而已
此函数的作用是把要创建的线程排队到线程池，当线程池的可用线程数不为零时（线程池有创建线程数的限制，缺身值为25），便创建此线程，否则就排队到线程池等到他有可用的线程时才创建。
public static registeredwaithandle registerwaitforsingleobject(
waithandle waitobject,// 要注册的 waithandle
waitortimercallback callback,// 线程调用的委托
object state,//传递给委托的参数
int timeout,//超时，单位为毫秒，
bool executeonlyonce file://是/否只执行一次
);
public delegate void waitortimercallback(
object state,//也即传递给委托的参数
bool timedout//true表示由于超时调用，反之则因为waitobject
);

此函数的作用是创建一个等待线程，一旦调用此函数便创建此线程，在参数waitobject变为终止状态或所设定的时间timeout到了之前，他都处于“阻塞”状态，值得注意的一点是此“阻塞”和thread的waitsleepjoin状态有非常大的不同：当某thread处于waitsleepjoin状态时cpu会定期的唤醒他以轮询更新状态信息，然后再次进入waitsleepjoin状态，线程的转换可是非常费资源的；而用此函数创建的线程则不同，在触发他运行之前，cpu不会转换到此线程，他既不占用cpu的时间又不浪费线程转换时间，但cpu又怎么知道何时运行他？实际上线程池会生成一些辅助线程用来监视这些触发条件，一旦达到条件便启动相应的线程，当然这些辅助线程本身也占用时间，不过如果你需创建较多的等待线程时，使用线程池的优势就越加明显。见下例：

static autoresetevent ev=new autoresetevent(false);
public static int main(string[] args)
{ threadpool.registerwaitforsingleobject(
ev,
new waitortimercallback(waitthreadfunc),
,
,
false//表示每次完成等待操作后都重置计时器，直到注销等待
);
threadpool.queueuserworkitem (new waitcallback (threadfunc),8);
thread.sleep (10000);
return 0;
}
public static void threadfunc(object b)
{ console.writeline ("the object is {0}",b);
for(int i=0;i<2;i++)
{ thread.sleep (1000);
ev.set();
}
}
public static void waitthreadfunc(object b,bool t)
{ console.writeline ("the object is {0},t is {1}",b,t);
}

其运行结果为：

the object is 8

the object is 4,t is false

the object is 4,t is true

从以上结果我们能看出线程threadfunc运行了1次，而waitthreadfunc运行了5次。我们能从waitortimercallback中的bool t参数判断启动此线程的原因：t为false，则表示由于waitobject，否则则是由于超时。另外我们也能通过object b向线程传递一些参数。
3． timer
提供以指定的时间间隔执行方法的机制。

使用 TimerCallback 委托指定希望 Timer 执行的方法。计时器委托在构造计时器时指定，并且不能更改。此方法不在创建计时器的线程上执行，而是在系统提供的 ThreadPool 线程上执行。

创建计时器时，可以指定在第一次执行方法之前等待的时间量（截止时间）以及此后的执行期间等待的时间量（时间周期）。可以使用 Change 方法更改这些值或禁用计时器。
只要在使用 Timer，就必须保留对它的引用。对于任何托管对象，如果没有对 Timer 的引用，计时器会被垃圾回收。即使 Timer 仍处在活动状态，也会被回收。
当不再需要计时器时，请使用 Dispose 方法释放计时器持有的资源。如果希望在计时器被释放时接收到信号，请使用接受 WaitHandle 的 Dispose(WaitHandle) 方法重载。计时器已被释放后，WaitHandle 便终止。

由计时器执行的回调方法应该是可重入的，因为它是在 ThreadPool 线程上调用的。在以下两种情况中，此回调可以同时在两个线程池线程上执行：一是计时器间隔小于执行此回调所需的时间；二是所有线程池线程都在使用，此回调被多次排队。

System.Threading.Timer 是一个简单的轻量计时器，它使用回调方法并由线程池线程提供服务。不建议将其用于 Windows 窗体，因为其回调不在用户界面线程上进行。 System.Windows.Forms.Timer 是用于 Windows 窗体的更佳选择。要获取基于服务器的计时器功能，可以考虑使用 System.Timers.Timer，它可以引发事件并具有其他功能。

这和win32中的settimer方法类似。他的构造为：

public timer(
timercallback callback,//所需调用的方法
object state,//传递给callback的参数
int duetime,//多久后开始调用callback
int period//调用此方法的时间间隔
);

// 如果 duetime 为0，则 callback 即时执行他的首次调用。如果 duetime 为 infinite，则 callback 不调用他的方法。计时器被禁用，但使用 change 方法能重新启用他。如果 period 为0或 infinite，并且 duetime 不为 infinite，则 callback 调用他的方法一次。计时器的定期行为被禁用，但使用 change 方法能重新启用他。如果 period 为零 (0) 或 infinite，并且 duetime 不为 infinite，则 callback 调用他的方法一次。计时器的定期行为被禁用，但使用 change 方法能重新启用他。
在创建计时器之后若想改动他的period和duetime，我们能通过调用timer的change方法来改动：
[c#]
public bool change(
int duetime,
int period
);//显然所改动的两个参数对应于timer中的两参数
见下例：

public static int main(string[] args)
{ console.writeline ("period is 1000");
timer tm=new timer (new timercallback (timercall),3,1000,1000);
thread.sleep (2000);
console.writeline ("period is 500");
tm.change (0,800);
thread.sleep (3000);
return 0;
}
public static void timercall(object b)
{
console.writeline ("timercallback; b is {0}",b);
}

其运行结果为：

period is 1000

timercallback;b is 3

period is 500

timercallback;b is 3

timercallback;b is 3
总结
从以上的简单介绍，我们能看出他们各自使用的场合：thread适用于那些需对线程进行复杂控制的场合；threadpool适应于一些需要多个线程而又较短任务（如一些常处于阻塞状态的线程）；timer则适用于那些需周期性调用的方法。只要我们了解了他们的使用特点，我们就能非常好的选择合适的方法。

本文转自linzheng 51CTO博客，原文链接:http://blog.51cto.com/linzheng/1085602

码农公寓

相关文章