多线程
在一个程序中,这些独立运行的程序片断叫作“线程”(Thread),利用它编程的概念就叫作“多线程处理”。多线程处理一个常见的例子就是用户界面。利用线程,用户可按下一个按钮,然后程序会立即作出响应,而不是让用户等待程序完成了当前任务以后才开始响应。
在计算机编程中,一个基本的概念就是同时对多个任务加以控制。许多程序设计问题都要求程序能够停下手头的工作,改为处理其他一些问题,再返回主进程。可以通过多种途径达到这个目的。最开始的时候,那些掌握机器低级语言的程序员编写一些“中断服务例程”,主进程的暂停是通过硬件级的中断实现的。尽管这是一种有用的方法,但编出的程序很难移植,由此造成了另一类的代价高昂问题。中断对那些实时性很强的任务来说是很有必要的。但对于其他许多问题,只要求将问题划分进入独立运行的程序片断中,使整个程序能更迅速地响应用户的请求。
英文:Thread
每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。进程也可能是整个程序或者是部分程序的动态执行。线程是一组指令的集合,或者是程序的特殊段,它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程,它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。
线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称为多线程.
线程和进程的区别在于,子进程和父进程有不同的代码和数据空间,而多个线程则共享数据空间,每个线程有自己的执行堆栈和程序计数器为其执行上下文.多线程主要是为了节约CPU时间,发挥利用,根据具体情况而定. 线程的运行中需要使用计算机的内存资源和CPU。
线程优缺点
缺点:
·如果有大量的线程,会影响性能,因为操作系统需要在他们之间切换;
·更多的线程需要更多的内存空间
·线程会给程序带来更多的bug,因此要小心使用
·线程的中止需要考虑其对程序运行的影响
·通常块模型数据是在多个线程间共享的,需要一个合适的锁系统替换掉数据共享
优点:
·使用线程可以把占据长时间的程序中的任务放到后台去处理
·用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度
·程序的运行速度可能加快
·在一些等待的任务实现上如用户输入、文件读写和网络收发数据等,线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。
多线程在.NET里如何工作?
在本质上和结构来说,.NET是一个多线程的环境。有两种主要的多线程方法是.NET所提倡的:使用ThreadStart来开始你自己的进程,直接的(使用ThreadPool.QueueUserWorkItem)或者间接的(比如Stream.BeginRead,或者调用BeginInvoke)使用ThreadPool类。一般来说,你可以"手动"为长时间运行的任务创建一个新的线程,另外对于短时间运行的任务尤其是经常需要开始的那些,进程池是一个非常好的选择。进程池可以同时运行多个任务,还可以使用框架类。对于资源紧缺需要进行同步的情况来说,它可以限制某一时刻只允许一个线程访问资源。这种情况可以视为给线程实现了锁机制。线程的基类是System.Threading。所有线程通过CLI来进行管理。
·创建线程:
创建一个新的Thread对象的实例。Thread的构造函数接受一个参数:
Thread DummyThread = new Thread( new ThreadStart(dummyFunction) );
·执行线程:
使用Threading命名空间里的start方法来运行线程:
DummyThread.Start ();
·组合线程:
经常会出现需要组合多个线程的情况,就是当某个线程需要其他线程的结束来完成自己的任务。假设DummyThread必须等待DummyPriorityThread来完成自己的任务,只需要这样做:
DummyPriorityThread.Join() ;
·暂停线程:
使得线程暂停给定的秒
DummyPriorityThread.Sleep();
·中止线程:
如果需要中止线程可以使用如下的代码:
DummyPriorityThread.Abort();
·同步
//线程间的互斥:并发执行的线程共享某些类临界资源,对临界资源的访问应当采取互斥的机制。
//线程间的同步:并发执行的线程间通常存在相互制约的关系,线程必须遵循一定的规则来执行,
//同步机制可以协调相互制约的关系。
DummyThread.Join();
DummyPriorityThread.Join();
·使用Interlock
C#提供了一个特殊的类叫做interlocked,就是提供了锁机制的实现,可以加入如下的代码实现锁机制:
Interlocked.SomeFunction (ref counter);
·使用锁
这是为了锁定代码关键区域以进行同步,锁定代码如下:
lock (this){ Some statements ;}
·使用Monitor
当有需要进行线程管理的时候可以使用:
Monitor.Enter(this);
其他也有一些方法进行管理,这里就不一一提及了。
具体事例参加《SynchronizationThreadsExample》《SynchronizationThreadExample1》
PS:例子1中说明:要实现线程同步不止这一种方式。在这里采用了事件,在事件处理程序里中止了线程。
OnNumberClear += new EventHandler(ThreadDemo_OnNumberClear);
OnNumberClear是事件
EventHandler是委托
ThreadDemo_OnNumberClear是方法名
上面这句代码的意思是当OnNumberClear事件激发后将由ThreadDemo_OnNumberClear方法进行处理。
C#线程使用方法 在.net中线程是由System.Threading 名字空间所定义的。所以你必须包含这个名字空间。 1. using System.Threading; 开始一个C#线程 System.Threading 名字空间的线程类描述了一个线程对象,通过使用类对象,你可以创建、删除、停止及恢复一个线程。创建一个新线程通过new 操作,并可以通过start()方法启动线程 1. thread = new Thread(new ThreadStart(HelloWorld)); 2. thread.Start(); 注意:和java程序不同,创建新线程并调用start()方法后并不去调用run()方法,而是传递线程调用程序,下面是启动线程执行的函数 1. protected void HelloWorld() 2. { 3. string str ; 4. Console.write("helloworld"); 5. } 杀死一个C#线程 线程类的 Abort()方法可以永久的杀死一个线程。在杀死一个线程起前应该判断线程是否在生存期间。 1. if ( thread.IsAlive ) 2. { 3. thread.Abort(); 4. } 停止一个C#线程 Thread.Sleep 方法能够在一个固定周期类停止一个线程 1. thread.Sleep(); 设定线程优先级 线程类中的ThreadPriority 属性是用来设定一个ThreadPriority的优先级别。线程优先级别包括Normal, AboveNormal, BelowNormal, Highest, and Lowest几种。 1. thread.Priority = ThreadPriority.Highest; 挂起一个C#线程 调用线程类的Suspend()方法将挂起一个线程直到使用Resume()方法唤起她。在挂起一个线程起前应该判断线程是否在活动期间。 唤起一个线程
通过使用Resume()方法可以唤起一个被挂起线程。在挂起一个线程起前应该判断线程是否在挂起期间,如果线程未被挂起则方法不起作用。 if (thread.ThreadState = ThreadState.Suspended ) { thread.Resume(); } |
C#多线程编程实例实战 单个写入程序/多个阅读程序在.Net类库中其实已经提供了实现,即System.Threading.ReaderWriterLock类。本文通过对常见的单个写入/多个阅读程序的分析来探索c#的多线程编程。 问题的提出 所谓单个写入程序/多个阅读程序的线程同步问题,是指任意数量的线程访问共享资源时,写入程序(线程)需要修改共享资源,而阅读程序(线程)需要读取数据。在这个同步问题中,很容易得到下面二个要求: 1) 当一个线程正在写入数据时,其他线程不能写,也不能读。 2) 当一个线程正在读入数据时,其他线程不能写,但能够读。 在数据库应用程序环境中经常遇到这样的问题。比如说,有n个最终用户,他们都要同时访问同一个数据库。其中有m个用户要将数据存入数据库,n-m个用户要读取数据库中的记录。 很显然,在这个环境中,我们不能让两个或两个以上的用户同时更新同一条记录,如果两个或两个以上的用户都试图同时修改同一记录,那么该记录中的信息就会被破坏。 我们也不让一个用户更新数据库记录的同时,让另一用户读取记录的内容。因为读取的记录很有可能同时包含了更新和没有更新的信息,也就是说这条记录是无效的记录。 实现分析 规定任一线程要对资源进行写或读操作前必须申请锁。根据操作的不同,分为阅读锁和写入锁,操作完成之后应释放相应的锁。将单个写入程序/多个阅读程序的要求改变一下,可以得到如下的形式: 一个线程申请阅读锁的成功条件是:当前没有活动的写入线程。 一个线程申请写入锁的成功条件是:当前没有任何活动(对锁而言)的线程。 因此,为了标志是否有活动的线程,以及是写入还是阅读线程,引入一个变量m_nActive,如果m_nActive > 0,则表示当前活动阅读线程的数目,如果m_nActive=0,则表示没有任何活动线程,m_nActive <0,表示当前有写入线程在活动,注意m_nActive<0,时只能取-1的值,因为只允许有一个写入线程活动。 为了判断当前活动线程拥有的锁的类型,我们采用了线程局部存储技术(请参阅其它参考书籍),将线程与特殊标志位关联起来。 申请阅读锁的函数原型为:public void AcquireReaderLock( int millisecondsTimeout ),其中的参数为线程等待调度的时间。函数定义如下:
public void AcquireReaderLock( int millisecondsTimeout ) {
// m_mutext很快可以得到,以便进入临界区 m_mutex.WaitOne( ); // 是否有写入线程存在 bool bExistingWriter = ( m_nActive < 0 ); if( bExistingWriter ) { //等待阅读线程数目加1,当有锁释放时,根据此数目来调度线程 m_nWaitingReaders++; }
else
{ //当前活动线程加1 m_nActive++; }
m_mutex.ReleaseMutex(); //存储锁标志为Reader
System.LocalDataStoreSlot slot = Thread.GetNamedDataSlot(m_strThreadSlotName); object obj = Thread.GetData( slot ); LockFlags flag = LockFlags.None; if( obj != null ) flag = (LockFlags)obj ; if( flag == LockFlags.None ) {
Thread.SetData( slot, LockFlags.Reader ); }
else
{
Thread.SetData( slot, (LockFlags)((int)flag | (int)LockFlags.Reader ) ); }
if( bExistingWriter ) { //等待指定的时间 this.m_aeReaders.WaitOne( millisecondsTimeout, true ); }
} | 它首先进入临界区(用以在多线程环境下保证活动线程数目的操作的正确性)判断当前活动线程的数目,如果有写线程(m_nActive<0)存在,则等待指定的时间并且等待的阅读线程数目加1。如果当前活动线程是读线程(m_nActive>=0),则可以让读线程继续运行。 申请写入锁的函数原型为:public void AcquireWriterLock( int millisecondsTimeout ),其中的参数为等待调度的时间。函数定义如下:
public void AcquireWriterLock( int millisecondsTimeout ) {
// m_mutext很快可以得到,以便进入临界区 m_mutex.WaitOne( ); // 是否有活动线程存在 bool bNoActive = (m_nActive == 0); if( !bNoActive ) {
m_nWaitingWriters++; }
else
{ m_nActive--; }
m_mutex.ReleaseMutex(); //存储线程锁标志
System.LocalDataStoreSlot slot = Thread.GetNamedDataSlot( "myReaderWriterLockDataSlot" ); object obj = Thread.GetData( slot ); LockFlags flag = LockFlags.None; if( obj != null ) flag = (LockFlags)Thread.GetData( slot ); if( flag == LockFlags.None ) {
Thread.SetData( slot, LockFlags.Writer ); }
else
{
Thread.SetData( slot, (LockFlags)((int)flag | (int)LockFlags.Writer ) ); } //如果有活动线程,等待指定的时间 if( !bNoActive ) this.m_aeWriters.WaitOne( millisecondsTimeout, true ); } | 它首先进入临界区判断当前活动线程的数目,如果当前有活动线程存在,不管是写线程还是读线程(m_nActive),线程将等待指定的时间并且等待的写入线程数目加1,否则线程拥有写的权限。 释放阅读锁的函数原型为:public void ReleaseReaderLock()。函数定义如下:
public void ReleaseReaderLock() {
System.LocalDataStoreSlot slot = Thread.GetNamedDataSlot(m_strThreadSlotName ); LockFlags flag = (LockFlags)Thread.GetData( slot ); if( flag == LockFlags.None ) { return;
}
bool bReader = true; switch( flag ) {
case LockFlags.None: break;
case LockFlags.Writer: bReader = false; break;
}
if( !bReader ) return;
Thread.SetData( slot, LockFlags.None ); m_mutex.WaitOne(); AutoResetEvent autoresetevent = null; this.m_nActive --; if( this.m_nActive == 0 ) {
if( this.m_nWaitingReaders > 0 ) {
m_nActive ++ ; m_nWaitingReaders --; autoresetevent = this.m_aeReaders; }
else if( this.m_nWaitingWriters > 0) {
m_nWaitingWriters--; m_nActive --; autoresetevent = this.m_aeWriters ; }
}
m_mutex.ReleaseMutex(); if( autoresetevent != null ) autoresetevent.Set(); } | 释放阅读锁时,首先判断当前线程是否拥有阅读锁(通过线程局部存储的标志),然后判断是否有等待的阅读线程,如果有,先将当前活动线程加1,等待阅读线程数目减1,然后置事件为有信号。如果没有等待的阅读线程,判断是否有等待的写入线程,如果有则活动线程数目减1,等待的写入线程数目减1。释放写入锁与释放阅读锁的过程基本一致,可以参看源代码。 注意在程序中,释放锁时,只会唤醒一个阅读程序,这是因为使用AutoResetEvent的原因,读者可自行将其改成ManualResetEvent,同时唤醒多个阅读程序,此时应令m_nActive等于整个等待的阅读线程数目。 测试 测试程序取自.Net FrameSDK中的一个例子,只是稍做修改。测试程序如下, 见实例《读写线程1》 从测试结果中可以看出,可以满足单个写入程序\多个阅读程序的实现要求 |
ReaderWriterLock 类
定义支持单个写线程和多个读线程的锁。
命名空间: System.Threading
程序集: mscorlib(在 mscorlib.dll 中)
[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true,
ExternalThreading = true)]
public sealed class ReaderWriterLock : CriticalFinalizerObject
ReaderWriterLock 用于同步对资源的访问。在任一特定时刻,它允许多个线程同时进行读访问,或者允许单个线程进行写访问。在资源不经常发生更改的情况下,ReaderWriterLock 所提供的吞吐量比简单的一次只允许一个线程的锁(如 Monitor)更高。
在多数访问为读访问,而写访问频率较低、持续时间也比较短的情况下,ReaderWriterLock 的性能最好。多个读线程与单个写线程交替进行操作,所以读线程和写线程都不会长时间阻止。
说明: |
长时间持有读线程锁或写线程锁会使其他线程发生饥饿 (starve)。为了得到最好的性能,需要考虑重新构造应用程序以将写访问的持续时间减少到最小。 |
一个线程可以持有读线程锁或写线程锁,但是不能同时持有两者。若要获取写线程锁,请使用 UpgradeToWriterLock 和 DowngradeFromWriterLock,而不要通过释放读线程锁的方式获取。
递归锁请求会增加锁上的锁计数。
读线程和写线程将分别排入各自的队列。当线程释放写线程锁时,此刻读线程队列中的所有等待线程都将被授予读线程锁;当已释放所有读线程锁时,写线程队列中处于等待状态的下一个线程(如果存在)将被授予写线程锁,依此类推。换句话说,ReaderWriterLock 在一组读线程和一个写线程之间交替进行操作。
当写线程队列中有一个线程在等待活动读线程锁被释放时,请求新的读线程锁的线程会排入读线程队列。即使它们能和现有的阅读器锁持有者共享并发访问,也不会给它们的请求授予权限;这有助于防止编写器被阅读器无限期阻止。
大多数在 ReaderWriterLock 上获取锁的方法都采用超时值。使用超时可以避免应用程序中出现死锁。例如,某个线程可能获取了一个资源上的写线程锁,然后请求第二个资源上的读线程锁;同时,另一个线程获取了第二个资源上的写线程锁,并请求第一个资源上的读线程锁。如果不使用超时,这两个线程将出现死锁。
如果超时间隔过期并且没有授予锁请求,则此方法通过引发 ApplicationException 将控制返回给调用线程。线程可以捕捉此异常并确定下一步要进行的操作。超时用毫秒表示。如果使用 System.TimeSpan 指定超时,则所用的值是 TimeSpan 所表示的毫秒整数的总和。下表显示用毫秒表示的有效超时值。
值 | 说明 |
-1 | 无论花费多长时间,线程都会一直等到获得锁为止。对于指定整数超时的方法,可以使用常数 Infinite。 |
0 | 线程不等待获取锁。如果无法立即获取锁,方法将返回。 |
>0 | 要等待的毫秒数。 |
除了 -1 以外,不允许使用负的超时值。如果指定一个除 -1 以外的负整数,超时值将使用零。(即:如果无法立即获取锁,方法将不等待而立即返回。) 如果指定的 TimeSpan 表示的是 -1 以外的负毫秒数,将引发 ArgumentOutOfRangeException。
下面的示例演示如何使用 ReaderWriterLock 保护由多线程同时读取并独占编写的共享资源。
请参见实例《读写线程1》、《读写线程2》
AutoResetEvent 类
[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true,
ExternalThreading = true)]
public sealed class AutoResetEvent : EventWaitHandle
AutoResetEvent 类表示一个本地等待处理事件,在释放了单个等待线程以后,该事件会在终止时自动重置。该类表示它的基类(即 EventWaitHandle)的特殊情况。有关自动重置事件的使用和功能,请参见 EventWaitHandle 概念文档。
在释放了单个等待线程以后,系统会自动将一个 AutoResetEvent 对象重置为非终止。如果没有线程在等待,事件对象的状态会保持为终止。AutoResetEvent 对应于 Win32 CreateEvent 调用,从而为 bManualReset 参数指定 false。
在 .NET Framework 2.0 版中,AutoResetEvent 从新的 EventWaitHandle 类派生。AutoResetEvent 在功能上等效于用 EventResetMode.AutoReset 创建的 EventWaitHandle。
AutoResetEvent 允许线程通过发信号互相通信。通常,此通信涉及线程需要独占访问的资源。
线程通过调用 AutoResetEvent 上的 WaitOne 来等待信号。如果 AutoResetEvent 为非终止状态,则线程会被阻止,并等待当前控制资源的线程通过调用 Set 来通知资源可用。
调用 Set 向 AutoResetEvent 发信号以释放等待线程。AutoResetEvent 将保持终止状态,直到一个正在等待的线程被释放,然后自动返回非终止状态。如果没有任何线程在等待,则状态将无限期地保持为终止状态。
如果当 AutoResetEvent 为终止状态时线程调用 WaitOne,则线程不会被阻止。AutoResetEvent 将立即释放线程并返回到非终止状态。
重要说明: |
不能保证对 Set 方法的每次调用都释放线程。如果两次调用十分接近,以致在线程释放之前便已发生第二次调用,则只释放一个线程。就像第二次调用并未发生一样。另外,如果在调用 Set 时不存在等待的线程且 AutoResetEvent 已终止,则该调用无效。 |
可以通过将一个布尔值传递给构造函数来控制 AutoResetEvent 的初始状态,如果初始状态为终止状态,则为 true;否则为 false。
AutoResetEvent 也可以同 staticWaitAll 和 WaitAny 方法一起使用。
有关线程同步机制的更多信息,请参见概念文档中的 AutoResetEvent。
实例:下面的代码示例阐释了如何使用等待句柄来发送复杂数字计算的不同阶段的完成信号。计算的格式为:结果 = 第一项 + 第二项 + 第三项,其中每一项都要求使用计算出的基数进行预计算和最终计算
参见《等待句柄来发送复杂数字计算的不同阶段的完成信号》
PS:Set()将事件状态设置为终止状态,允许一个或多个等待线程继续;Reset()将事件状态设置为非终止状态,导致线程阻止。
WaitOne()阻止当前线程,直到当前System.Threading.WaitHandle收到信号
监视器
Monitor 对象通过使用 Monitor.Enter、Monitor.TryEnter 和 Monitor.Exit 方法对特定对象获取锁和释放锁来公开同步访问代码区域的能力。在对代码区域获取锁后,就可以使用 Monitor.Wait、Monitor.Pulse 和 Monitor.PulseAll 方法了。如果锁被暂挂,则 Wait 释放该锁并等待通知。当 Wait 接到通知后,它将返回并再次获取该锁。Pulse 和 PulseAll 都会发出信号以便等待队列中的下一个线程继续执行。
Visual Basic SyncLock 和 C# lock 语句使用 Monitor.Enter 获取锁,使用 Monitor.Exit 释放锁。使用语言语句的优点在于 lock 或 SyncLock 块中的所有内容都包含在 Try 语句中。Try 语句有一个 Finally 块,用以保证锁得以释放。
Monitor 将锁定对象(即引用类型),而非值类型。尽管可以向 Enter 和 Exit 传递值类型,但对于每次调用它都是分别装箱的。因为每次调用都创建一个独立的对象,所以 Enter 永远不会阻止,而且它要保护的代码并没有真正同步。另外,传递给 Exit 的对象不同于传递给 Enter 的对象,所以 Monitor 引发 SynchronizationLockException,并显示以下消息:“从不同步的代码块中调用了对象同步方法”。下面的示例演示这些问题。
private int x;
// The next line creates a generic object containing the value of
// x each time the code is executed, so that Enter never blocks.
Monitor.Enter(x);
try {
// Code that needs to be protected by the monitor.
}
finally {
// Always use Finally to ensure that you exit the Monitor.
// The following line creates another object containing
// the value of x, and throws SynchronizationLockException
// because the two objects do not match.
Monitor.Exit(x);
}
尽管您可以如下面的示例所示,在调用 Enter 和 Exit 之前将值类型变量装箱,并将同一个装箱的对象传递给这两个方法,但这样做并没有什么特别的用处。对变量的更改不能在装箱的变量中体现出来,也没有办法更改已装箱的变量的值。
private Object o = x;
注意到 Monitor 和 WaitHandle 对象在使用上的区别是非常重要的。Monitor 对象是完全托管、完全可移植的,并且在操作系统资源要求方面可能更为有效。WaitHandle 对象表示操作系统可等待对象,对于在托管和非托管代码之间进行同步非常有用,并公开一些高级操作系统功能(如同时等待许多对象的能力)。
下面的代码示例演示 Monitor 类(使用 lock 和 SyncLock 编译器语句实现)、Interlocked 类和 AutoResetEvent 类的结合使用。
using System;
using System.Threading;
// Note: The class whose internal public member is the synchronizing
// method is not public; none of the client code takes a lock on the
// Resource object.The member of the nonpublic class takes the lock on
// itself. Written this way, malicious code cannot take a lock on
// a public object.
class SyncResource
{
public void Access(Int32 threadNum)
{
// Uses Monitor class to enforce synchronization.
lock (this) {
// Synchronized: Despite the next conditional, each thread
// waits on its predecessor.
if (threadNum % 2 == 0)
Thread.Sleep(2000);
Console.WriteLine("Start Synched Resource access (Thread={0})", threadNum);
Thread.Sleep(200);
Console.WriteLine("Stop Synched Resource access (Thread={0})", threadNum);
}
}
}
// Without the lock, the method is called in the order in which threads reach it.
class UnSyncResource
{
public void Access(Int32 threadNum)
{
// Does not use Monitor class to enforce synchronization.
// The next call throws the thread order.
if (threadNum % 2 == 0)
Thread.Sleep(2000);
Console.WriteLine("Start UnSynched Resource access (Thread={0})", threadNum);
Thread.Sleep(200);
Console.WriteLine("Stop UnSynched Resource access (Thread={0})", threadNum);
}
}
public class App
{
static Int32 numAsyncOps = 5;
static AutoResetEvent asyncOpsAreDone = new AutoResetEvent(false);
static SyncResource SyncRes = new SyncResource();
static UnSyncResource UnSyncRes = new UnSyncResource();
public static void Main()
{
for (Int32 threadNum = 0; threadNum < 5; threadNum++)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(SyncUpdateResource), threadNum);
}
// Wait until this WaitHandle is signaled.
asyncOpsAreDone.WaitOne();
Console.WriteLine("\t\nAll synchronized operations have completed.\t\n");
// Reset the thread count for unsynchronized calls.
numAsyncOps = 5;
for (Int32 threadNum = 0; threadNum < 5; threadNum++)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(UnSyncUpdateResource), threadNum);
}
// Wait until this WaitHandle is signaled.
asyncOpsAreDone.WaitOne();
Console.WriteLine("\t\nAll unsynchronized thread operations have completed.");
}
// The callback method's signature MUST match that of a
// System.Threading.TimerCallback delegate (it takes an Object
// parameter and returns void).
static void SyncUpdateResource(Object state) {
// This calls the internal synchronized method, passing
// a thread number.
SyncRes.Access((Int32) state);
// Count down the number of methods that the threads have called.
// This must be synchronized, however; you cannot know which thread
// will access the value **before** another thread's incremented
// value has been stored into the variable.
if (Interlocked.Decrement(ref numAsyncOps) == 0)
asyncOpsAreDone.Set();
// Announce to Main that in fact all thread calls are done.
}
// The callback method's signature MUST match that of a
// System.Threading.TimerCallback delegate (it takes an Object
// parameter and returns void).
static void UnSyncUpdateResource(Object state) {
// This calls the unsynchronized method, passing a thread number.
UnSyncRes.Access((Int32) state);
// Count down the number of methods that the threads have called.
// This must be synchronized, however; you cannot know which thread
// will access the value **before** another thread's incremented
// value has been stored into the variable.
if (Interlocked.Decrement(ref numAsyncOps) == 0)
asyncOpsAreDone.Set();
// Announce to Main that in fact all thread calls are done.
}
}