Php文档 Php问答行业资讯 Php论坛 Php手册 Php博客

游戏榜单

软件榜单

关闭导航

热搜榜

热门下载

热门标签

关闭搜索

php爱好者> php文档>C#多线程编程介绍——使用thread、threadpool、timer

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

时间：2011-02-21 来源：linzheng

然后调用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; 
a = 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), 
4, 
2000, 
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则适用于那些需周期性调用的方法。只要我们了解了他们的使用特点，我们就能非常好的选择合适的方法。