解决多线程 共享资源

delphi中多线程同步的一些方法 
当有多个线程的时候，经常需要去同步这些线程以访问同一个数据或资源。例如，假设有一个程序，其中一个线程用于把文件读到内存，而另一个线程用于统计文件中的字符数。当然，在把整个文件调入内存之前，统计它的计数是没有意义的。但是，由于每个操作都有自己的线程，操作系统会把两个线程当作是互不相干的任务分别执行，这样就可能在没有把整个文件装入内存时统计字数。为解决此问题，你必须使两个线程同步工作。 
存在一些线程同步地址的问题，Win32提供了许多线程同步的方式。在本节你将看到使用临界区、 互斥、信号量和事件来解决线程同步的问题。

1. 临界区 
临界区是一种最直接的线程同步方式。所谓临界区，就是一次只能由一个线程来执行的一段代码。如果把初始化数组的代码放在临界区内，另一个线程在第一个线程处理完之前是不会被执行的。 
在使用临界区之前，必须使用InitializeCriticalSection()过程来初始化它。 
其声明如下： 
  procedure InitializeCriticalSection(var 
lpCriticalSection参数是一个TRTLCriticalSection类型的记录，并且是变参。至于TRTLCriticalSection 是如何定义的，这并不重要，因为很少需要查看这个记录中的具体内容。只需要在lpCriticalSection中传递未初始化的记录，InitializeCriticalSection()过程就会填充这个记录。 
注意Microsoft故意隐瞒了TRTLCriticalSection的细节。因为，其内容在不同的硬件平台上是不同的。在基于Intel的平台上，TRTLCriticalSection包含一个计数器、一个指示当前线程句柄的域和一个系统事件的句柄。在Alpha平台上，计数器被替换为一种Alpha-CPU 数据结构，称为spinlock。在记录被填充后，我们就可以开始创建临界区了。这时我们需要用EnterCriticalSection()和LeaveCriticalSection()来封装代码块。这两个过程的声明如下： 
  
procedure EnterCriticalSection(var lpCriticalSection:TRRLCriticalSection);stdcall; 
procedure LeaveCriticalSection(var 
正如你所想的，参数lpCriticalSection就是由InitializeCriticalSection()填充的记录。 
当你不需要TRTLCriticalSection记录时，应当调用DeleteCriticalSection()过程，下面是它的声明： 
procedure DeleteCriticalSection(var

2. 互斥 
互斥非常类似于临界区，除了两个关键的区别：首先，互斥可用于跨进程的线程同步。其次，互斥能被赋予一个字符串名字，并且通过引用此名字创建现有互斥对象的附加句柄。 
提示临界区与事件对象(比如互斥对象)的最大的区别是在性能上。临界区在没有线程冲突时，要用1 0 ~ 1 5个时间片，而事件对象由于涉及到系统内核要用400~600个时间片。 
可以调用函数CreateMutex ( )来创建一个互斥量。下面是函数的声明： 
function

lpMutexAttributes参数为一个指向TSecurityAttributtes记录的指针。此参数通常设为0，表示默认的安全属性。bInitalOwner参数表示创建互斥对象的线程是否要成为此互斥对象的拥有者。当此参数为False时， 表示互斥对象没有拥有者。 
lpName参数指定互斥对象的名称。设为nil表示无命名，如果参数不是设为nil，函数会搜索是否有同名的互斥对象存在。如果有，函数就会返回同名互斥对象的句柄。否则，就新创建一个互斥对象并返回其句柄。 
当使用完互斥对象时，应当调用CloseHandle()来关闭它。

在程序中使用WaitForSingleObject()来防止其他线程进入同步区域的代码。此函数声明如下： 
function

这个函数可以使当前线程在dwMilliseconds指定的时间内睡眠，直到hHandle参数指定的对象进入发信号状态为止。一个互斥对象不再被线程拥有时，它就进入发信号状态。当一个进程要终止时，它就进入发信号状态。dwMilliseconds参数可以设为0，这意味着只检查hHandle参数指定的对象是否处于发信号状态，而后立即返回。dwMilliseconds参数设为INFINITE，表示如果信号不出现将一直等下去。 
这个函数的返回值如下 
WaitFor SingleObject()函数使用的返回值 
返回值 含义 
WAIT_ABANDONED 指定的对象是互斥对象，并且拥有这个互斥对象的线程在没有释放此对象之前就已终止。此时就称互斥对象被抛弃。这种情况下，这个互斥对象归当前线程所有，并把它设为非发信号状态 
WAIT_OBJECT_0 指定的对象处于发信号状态 
WAIT_TIMEOUT等待的时间已过，对象仍然是非发信号状态再次声明，当一个互斥对象不再被一个线程所拥有,它就处于发信号状态。此时首先调用WaitForSingleObject()函数的线程就成为该互斥对象的拥有者，此互斥对象设为不发信号状态。当线程调用ReleaseMutex()函数并传递一个互斥对象的句柄作为参数时，这种拥有关系就被解除，互斥对象重新进入发信号状态。 
注意除WaitForSingleObject()函数外，你还可以使用WaitForMultipleObject()和MsgWaitForMultipleObject()函数，它们可以等待几个对象变为发信号状态。这两个函数的详细情况请看Win32 API联机文档。

3. 信号量 
另一种使线程同步的技术是使用信号量对象。它是在互斥的基础上建立的，但信号量增加了资源计数的功能，预定数目的线程允许同时进入要同步的代码。可以用CreateSemaphore()来创建一个信号量对象，其声明如下： 
function

和CreateMutex()函数一样，CreateSemaphore()的第一个参数也是一个指向TSecurityAttribute s记录的指针，此参数的缺省值可以设为nil。 
lInitialCount参数用来指定一个信号量的初始计数值，这个值必须在0和lMaximumCount之间。此参数大于0，就表示信号量处于发信号状态。当调用WaitForSingleObject()函数(或其他函数)时，此计数值就减1。当调用ReleaseSemaphore()时，此计数值加1。 
参数lMaximumCount指定计数值的最大值。如果这个信号量代表某种资源，那么这个值代表可用资源总数。 
参数lpName用于给出信号量对象的名称，它类似于CreateMutex()函数的lpName参数。

——————————————————————————————————————————

★★★关于线程同步： 
Synchronize()是在一个隐蔽的窗口里运行，如果在这里你的任务很繁忙，你的主窗口会阻塞掉；Synchronize()只是将该线程的代码放到主线程中运行，并非线程同步。

临界区是一个进程里的所有线程同步的最好办法，他不是系统级的，只是进程级的，也就是说他可能利用进程内的一些标志来保证该进程内的线程同步，据Richter说是一个记数循环；临界区只能在同一进程内使用；临界区只能无限期等待，不过2k增加了TryEnterCriticalSection函数实现0时间等待。

互斥则是保证多进程间的线程同步，他是利用系统内核对象来保证同步的。由于系统内核对象可以是有名字的，因此多个进程间可以利用这个有名字的内核对象保证系统资源的线程安全性。互斥量是Win32 内核对象，由操作系统负责管理；互斥量可以使用WaitForSingleObject实现无限等待，0时间等待和任意时间等待。

1. 临界区 
临界区是一种最直接的线程同步方式。所谓临界区，就是一次只能由一个线程来执行的一段代码。如果把初始化数组的代码放在临界区内，另一个线程在第一个线程处理完之前是不会被执行的。在使用临界区之前，必须使用InitializeCriticalSection()过程来初始化它。 
在第一个线程调用了EnterCriticalSection()之后，所有别的线程就不能再进入代码块。下一个线程要等第一个线程调用LeaveCriticalSection()后才能被唤醒。

2. 互斥 
互斥非常类似于临界区，除了两个关键的区别：首先，互斥可用于跨进程的线程同步。其次，互斥能被赋予一个字符串名字，并且通过引用此名字创建现有互斥对象的附加句柄。 
提示：临界区与事件对象(比如互斥对象)的最大的区别是在性能上。临界区在没有线程冲突时，要用10 ~ 15个时间片，而事件对象由于涉及到系统内核要用400~600个时间片。 
当一个互斥对象不再被一个线程所拥有,它就处于发信号状态。此时首先调用WaitForSingleObject()函数的线程就成为该互斥对象的拥有者，此互斥对象设为不发信号状态。当线程调用ReleaseMutex()函数并传递一个互斥对象的句柄作为参数时，这种拥有关系就被解除，互斥对象重新进入发信号状态。 
可以调用函数CreateMutex()来创建一个互斥量。当使用完互斥对象时，应当调用CloseHandle()来关闭它。

3. 信号量 
另一种使线程同步的技术是使用信号量对象。它是在互斥的基础上建立的，但信号量增加了资源计数的功能，预定数目的线程允许同时进入要同步的代码。可以用CreateSemaphore()来创建一个信号量对象， 
因为只允许一个线程进入要同步的代码，所以信号量的最大计数值(lMaximumCount)要设为1。ReleaseSemaphore()函数将使信号量对象的计数加1； 
记住，最后一定要调用CloseHandle()函数来释放由CreateSemaphore()创建的信号量对象的句柄。

★★★WaitForSingleObject函数的返值： 
WAIT_ABANDONED指定的对象是互斥对象，并且拥有这个互斥对象的线程在没有释放此对象之前就已终止。此时就称互斥对象被抛弃。这种情况下，这个互斥对象归当前线程所有，并把它设为非发信号状态； 
WAIT_OBJECT_0 指定的对象处于发信号状态； 
WAIT_TIMEOUT等待的时间已过，对象仍然是非发信号状态；

—————————————————————————————————————————————— 
VCL支持三种技术来达到这个目的： 
（2） 使用critical区 
如果对象没有提高内置的锁定功能，需要使用critical区，Critical区在同一个时间只也许一个线程进入。为了使用Critical区，产生一个TCriticalSection全局的实例。TcriticalSection有两个方法，Acquire(阻止其他线程执行该区域)和Release(取消阻止)

　　每个Critical区是与你想要保护的全局内存相关联。每个访问全局内存的线程必须首先使用Acquire来保证没有其他线程使用它。完成以后，线程调用Release方法，让其他线程也可以通过调用Acquire来使用这块全局内存。

　　警告：Critical区只有在所有的线程都使用它来访问全局内存，如果有线程直接调用内存，而不通过Acquire，会造成同时访问的问题。例如：LockXY是一个全局的Critical区变量。任何一个访问全局X, Y的变量的线程，在访问前，都必须使用Acquire 
LockXY.Acquire; { lock out other threads } 
try 
Y := sin(X); 
finally 
LockXY.Release; 
end 
临界区主要是为实现线程之间同步的，但是使用的时候注意，一定要在用此临界对象同步的线程之外建立该对象（一般在主线程中建立临界对象）。

———————————————————————————————————————————————— 
线程同步使用临界区，进程同步使用互斥对象。

Delphi中封装了临界对象。对象名为TCriticalSection，使用的时候只要在主线程当中建立这个临界对象（注意一定要在需要同步的线程之外建立这个对象）。具体同步的时候使用Lock和Unlock即可。 
而进程间同步建立互斥对象，则只需要建立一个互斥对象CreateMutex. 需要同步的时候只需要WaitForSingleObject(mutexhandle, INFINITE) unlock的时候只需要ReleaseMutex(mutexhandle);即可。

有很多方法, 信号灯, 临界区, 互斥对象,此外, windows下还可以用全局原子,共享内存等等. 在windows体系中, 读写一个8位整数时原子的, 你可以依靠这一点完成互斥的方法. 对于能够产生全局名称的方法能够可以在进程间同步上(如互斥对象), 也可以用在线程间同步上;不能够产生全局名称的方法(如临界区)只能用在线程间同步上.

一.什么是多线程？ 

线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称为多线程.

所有的线程虽然在微观上是串行执行的，但是在宏观上你完全可以认为它们在并行执行

二.那什么是线程呢？

线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。

这里的代码区共享和共同执行同样的函数就是我们多线程处理的关键！！

Thread类有几个至关重要的方法，描述如下：

Start()：启动线程；

Sleep(int)：静态方法，暂停当前线程指定的毫秒数；

Abort()：通常使用该方法来终止一个线程；

Suspend()：该方法并不终止未完成的线程，它仅仅挂起线程，以后还可恢复；

Resume()：恢复被Suspend()方法挂起的线程的执行；

但是在.net framework中一些线程的使用方法resume()，Suspend()，已经过时

resume():继续已挂起的线程。

Suspend()：挂起线程，或者如果线程已挂起，则不起作用

我在想是不是这些方法只是封装起来了，或者是由于这些方法容易导致程序错误

是不是但我们调用waitOne()方法的时候，当前线程就被挂起了呢？

而当我们使用EventWaitHandle.Set 方法时会resume()原先挂起的线程？

在前面线程的定义中提到了："线程的代码区是共享的，即不同的线程可以执行同样的函数。"

这就带来了一个麻烦，那就是当多个线程同时访问该代码段，改变代码段上的数据时，我们无法确切的知道数据的准确结果，因为我们无法知道某一时有哪几个线程访问了代码段，修改了数据，在编程的过程中这种不确定性必须消除的！！ 

三.如何来消除共享代码段带来的数据不确定性呢？

　　微软提供了一下几种方法：

独占锁(Lock)：锁定的最简单的形式是 C# 的 lock 语句，该语句可控制对代码块的访问。

Monitor 类：使用 Enter 和 Exit 方法标记临界区的开头和结尾。而lock 关键字在块的开始处调用 Enter，而在块的结尾处调用 Exit。 所以从本质上来讲Lock就是对Monitor的封装。只不过Lock比Monitor看上去要简洁一些。

其中Monitor类中还包括了两个类分别是；pulse()和Wait()方法；这各方法可以很方便的对线程状态Running运行，WaitSleepJoin封锁进行控制。

有两个方法要提一下，有时候线程的实现就靠这两个了！！

Thread.Join 方法 ：阻塞调用线程，直到某个线程终止时为止。

Monitor.Pulse 方法：通知等待队列中的线程锁定对象状态的更改。也就是在接收到脉冲后，等待线程就被移动到就绪队列中。在调用 Pulse 的线程释放锁后，就绪队列中的下一个线程（不一定是接收到脉冲的线程）将获得该锁。

上面我理解的是如果对代码段中的数据的访问，是为了避免多线程访问时，数据出现不确定性，出现数据库中所谓的脏数据。

下面我理解的是线程之间的执行顺序的问题，换句话说就是根据事情的先后次序来处理Thread。貌似就好比一条流水线。

多线程处理的时候，我们通常是同时开启多个要处理的线程，如果是按事情的先后顺序来处理线程的话，当某个线程运行到某处，必须接受另外一个线程的结果才能继续运行，那么这个时候线程必须封锁，处于等待状态。

我们的主角出来了，那就WaitHandle 类，封装等待对共享资源的独占访问的操作系统特定的对象。

四.WaitHandle 类：

下面来简单介绍一下这个类：既然是用来封锁等待线程的，那么不可避免的会有wait方法：WaitOne()，WaitAny(WaitHandle[]) ，WaitAll(WaitHandle[]) ，同时当某一线程等来了需要的数据时，我们还要唤醒这个线程，要发一个信号给这个线程，"数据已经准备好了，可以继续运行了"

所以Waithandle类提供了SignalAndWait(WaitHandle, WaitHandle)：向一个 WaitHandle 发出信号并等待另一个。

微软为了方面开发人员使用，还对WaitHandle类进行了扩展继承，下面来看看有哪些继承类  

1.System.Threading.EventWaitHandle ：表示一个线程同步事件。 

EventWaitHandle 类允许线程通过发信号互相通信。

通常，一个或多个线程在 EventWaitHandle 上阻止，直到一个未阻止的线程调用 Set 方法，以释放一个或多个被阻止的线程。

它又包括一下两个继承类：

1. 1. System.Threading.AutoResetEvent 自动重置事件提供对资源的独占访问。

      如果在没有线程等待时发出自动重置事件信号，则该信号将一直保留到有一个线程尝试在其上等待为止。

      然后，该事件释放线程并立即重置，这会阻止后面的线程。

   2. System.Threading.ManualResetEvent     手动重置事件类似于入口。

      当事件不处于终止状态时，在该事件上等待的线程将阻止。

      当事件处于终止状态时，所有等待的线程都被释放，而事件一直保持终止状态（即后面的等待不阻止），直到它的 Reset 方法被调用。

      如果一个线程必须完成一项活动后，其他线程才能继续，则手动重置事件很有用。

下面是我对EventWaithandle的理解：

首先主线程初始化一个EventWaitHandle的类实例，private static EventWaitHandle ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

它可以有两种模式，AutoReset和ManualReset，我们从字面上发现两个模式都带有一个相同的字段Reset，

我们联想一下EventHandle类中是不是有个方法叫做Reset： 将事件状态设置为非终止状态，导致线程阻止。那么进一步猜想，是不是AutoReset模式就是自动调用了Reset()方法，也就是在自动事件状态设置为非终止状态呢？

这是官方说明：

调用 Set 向 AutoResetEvent 发信号以释放等待线程。

AutoResetEvent 将保持终止状态，直到一个正在等待的线程被释放，然后自动返回非终止状态。 如果没有任何线程在等待，则状态将无限期地保持为终止状态。

 

说明我们的猜想是正确的！！！那前面我们所说的事件又是什么呢？初始化一个EventWaitHandle实例又是什么意思呢？与我们所讲到的多线程又有什么关联呢？我理解的前面提到的事件也就是一个线程，而初始化一个EventWaitHandle实例，也就是初始化一个线程，只不过这个线程只做一件事就是"卡位"，"堵口子"。强制其他线程等待，只有当这个事件处于终止状态的时候，也就是调用set(),其他处于等待线程才能得到释放，才可以运行，而当这个事件处于非终止状态的时候,也就是调用Reset()时，其他线程调用WaitOne就会使线程处于等待状态。也就是说其实EventWaitHandle，就是利用一个线程不断的抢占和释放资源，以便控制线程的执行顺序，达到多线程先后运行的目的！！System.Threading.Mutex:一个同步基元，也可用于进程间同步。 

  当两个或更多线程需要同时访问一个共享资源时，系统需要使用同步机制来确保一次只有一个线程使用该资源。    

2.System.Threading.Mutex:一个同步基元，也可用于进程间同步。 

当两个或更多线程需要同时访问一个共享资源时，系统需要使用同步机制来确保一次只有一个线程使用该资源。

Mutex 是同步基元，它只向一个线程授予对共享资源的独占访问权。

如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。

这与前面我解释的原因是一样的，就是利用一个线程控制其他线程的ThreadState状态，使线程的状态处于运行Running或是封锁WaitSleepJoin状态！ 

3.System.Threading.Semaphore：限制可同时访问某一资源或资源池的线程数。

这种处理是对前面的方法的进一步处理，就好比.net中的委托delegate和事件委托Event delegate，事件委托中可以多播委托。也就是构造了一个数组存储多个委托。并且可以对委托数组进行-=和+=。

这里的信号量也有类型的封装，信号量中存在一个数组Threadpool线程池，其实是一个队列。用来存放线程。当一个线程结束或是线程池为空时，其他处于waitOne中的线程就可以进入线程池，改变处于Wait状态TreadState的线程为Running。而运行完的线程就会从队列的头部出去。后来的进程从尾部进去。

总结一下: 继承WaitHandle类的几个类所作的事情无非是在改变线程的状态，来控制线程的执行顺序。