Delphi 中多线程同步的一些处理方法

当创建了多个线程，并且多个线程都要访问同一资源，，就有可能出现混乱，于是用Synchronize来控制，使同一时间只有一个线程使用那部分资源，Synchronize参数里面的代码就是多线程需要公共的代码！

线程是进程内一个相对独立的、可调度的执行单元。一个应用可以有一个主线程，一个主线程可以有多个子线程，子线程还可以有自己的子线程，这样就构成了多线程应用了。由于多个线程往往会同时访问同一块内存区域，频繁的访问这块区域，将会增加产生线程冲突的概率。一旦产生了冲突，将会造成不可预料的结果（该公用区域的值是不可预料的）可见处理线程同步的必要性。
　　注意：本文中出现的所有代码都是用DELPHI描述的，调试环境为Windows me ，Delphi 6。其中所涉及的Windows API函数可以从MSDN获得详细的文档。
　　首先引用一个实例来引出我们以下的讨论，该实例没有采取任何措施来避免线程冲突，它的主要过程为：由主线程启动两个线程对letters这个全局变量进行频繁的读写，然后分别把修改的结果显示到ListBox中。由于没有同步这两个线程，使得线程在修改letters时产生了不可预料的结果。
　　 ListBox中的每一行的字母都应该一致，但是上图画线处则不同，这就是线程冲突产生的结果。当两个线程同时访问该共享内存时，一个线程还未对该内存修改完，另一个线程又对该内存进行了修改，由于写值的过程没有被串行化，这样就产生了无效的结果。可见线程同步的重要性。

　　 以下是本例的代码

　　 unit.pas文件
　　 unit Unit1;
　　 interface
　　 uses
　　 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
　　 Dialogs, StdCtrls;
　　
　　 //定义窗口类
　　 type
　　 TForm1 = class(TForm)
　　 ListBox1: TListBox;
　　 ListBox2: TListBox;
　　 Button1: TButton;
　　 procedure Button1Click(Sender: TObject);
　　 private
　　 { Private declarations }
　　 public
　　 { Public declarations }
　　 end;
　　
　　 //定义线程类
　　 type
　　 TListThread=class(TThread)
　　 private
　　 Str:String;
　　 protected
　　 procedure AddToList;//将Str加入ListBox组件
　　 Procedure Execute;override;
　　 public
　　 LBox:TListBox;
　　 end;
　　 //定义变量
　　 var
　　 Form1: TForm1;
　　 Letters:String='AAAAAAAAAAAAAAAAAAAA';//全局变量
　　
　　 implementation
　　
　　 {$R *.dfm}
　　
　　 //线程类实现部分
　　 procedure TListThread.Execute;
　　 var
　　 I,J,K:Integer;
　　 begin
　　 for i:=0 to 50 do
　　 begin
　　 for J:=1 to 20 do
　　 for K:=1 to 1000 do//循环1000次增加产生冲突的几率
　　 if letters[j]<'Z' then
　　 letters[j]:=succ(Letters[j])
　　 else
　　 letters[j]:='A';
　　 str:=letters;
　　 synchronize(addtolist);//同步访问VCL可视组件
　　 end;
　　 end;
　　
　　 procedure TListThread.AddToList;
　　 begin
　　 LBox.Items.Add(str);//将str加入列表框
　　 end;
　　
　　 //窗口类实现部分
　　 procedure TForm1.Button1Click(Sender: TObject);
　　 var
　　 th1,th2:TListThread;
　　 begin
　　 Listbox1.Clear;
　　 Listbox2.Clear;
　　 th1:=tlistThread.Create(true);//创建线程1
　　 th2:=tlistThread.Create(true);//创建线程2
　　 th1.LBox:=listBox1;
　　 th2.LBox:=listBox2;
　　 th1.Resume;//开始执行
　　 th2.Resume;
　　 end;
　　 end.
　　
　　由上例可见，当多个线程同时修改一个公用变量时，会产生冲突，所以我们要设法防止它，这样我们开发的多线程应用才能够稳定地运行。下面我们来改进它。我们先使用临界段来串行化，实现同步。在上例unit1.pas代码的uses段中加入SyncObjs单元，加入全局临界段变量（TRTLCriticalSection）Critical1，在FormCreate事件中加入InitializeCriticalSection(Critical1)这句代码，在FormDestroy事件中加入DeleteCriticalSection(Critical1)这句代码，然后修改TListThread.Execute函数，修改后的代码似如下所示（?处为增加的代码）：
　　 procedure TListThread.Execute;
　　 var
　　 I,J,K:Integer;
　　 begin
　　 for i:=0 to 50 do
　　 begin
　　 ?EnterCriticalSection(Critical1);//进入临界段
　　 for J:=1 to 20 do
　　 for K:=1 to 3000 do
　　 if letters[j]<'Z' then
　　 letters[j]:=succ(Letters[j])
　　 else
　　 letters[j]:='A';
　　 str:=letters;
　　 ?LeaveCriticalSection(Critical1);//退出临界段
　　 synchronize(addtolist);
　　 end;
　　 end;
　　好了，重新编译，运行结果如下图所示(略)
　　
　　程序成功的避免了冲突，看来真的很简单，我们成功了！当然我们还可以使用其它同步技术如Mutex（互斥对象）, Semaphore（信号量）等，这些技术都是Windows通过API直接提供给我们的。

　　
　　 下面总结一下Windows常用的几种线程同步技术。

　　 1. Critical Sections（临界段），源代码中如果有不能由两个或两个以上线程同时执行的部分，可以用临界段来使这部分的代码执行串行化。它只能在一个独立的进程或一个独立的应用程序中使用。使用方法如下：
　　 //在窗体创建中
　　 InitializeCriticalSection(Critical1)
　　 //在窗体销毁中
　　 DeleteCriticalSection(Critical1)
　　 //在线程中
　　 EnterCriticalSection(Critical1)
　　 ……保护的代码
　　 LeaveCriticalSection(Critical1)
　　 2. Mutex（互斥对象），是用于串行化访问资源的全局对象。我们首先设置互斥对象，然后访问资源，最后释放互斥对象。在设置互斥对象时，如果另一个线程（或进程）试图设置相同的互斥对象，该线程将会停下来，直到前一个线程（或进程）释放该互斥对象为止。注意它可以由不同应用程序共享。使用方法如下：
　　 //在窗体创建中
　　 hMutex:=CreateMutex(nil,false,nil)
　　 //在窗体销毁中
　　 CloseHandle(hMutex)
　　 //在线程中
　　 WaitForSingleObject(hMutex,INFINITE)
　　 ……保护的代码
　　 ReleaseMutex(hMutex)
　　 3. Semaphore（信号量），它与互斥对象相似，但它可以计数。例如可以允许一个给定资源同时同时被三个线程访问。其实Mutex就是最大计数为一的Semaphore。使用方法如下：
　　 //在窗体创建中
　　 hSemaphore:= CreateSemaphore(nil,lInitialCount,lMaximumCount,lpName)
　　 //在窗体销毁中
　　 CloseHandle(hSemaphore)
　　 //在线程中
　　 WaitForSingleObject(hSemaphore,INFINITE)
　　 ……保护的代码
　　 ReleaseSemaphore(hSemaphore, lReleaseCount, lpPreviousCount)
　　 4. 还可以使用Delphi中的TcriticalSection这个VCL对象，它的定义在Syncobjs.pas中。
　　
　　当你开发多线程应用时，并且多个线程同时访问一个共享资源或数据时，你需要考虑线程同步的问题了。
　　
　　 delphi中多线程同步的一些方法
　　 [ 2006-01-09 10:48:03 | 作者: snox 字体大小:大 |中 |小 ]
　　当有多个线程的时候，经常需要去同步这些线程以访问同一个数据或资源。例如，假设有一个程序，其中一个线程用于把文件读到内存，而另一个线程用于统计文件中的字符数。当然，在把整个文件调入内存之前，统计它的计数是没有意义的。但是，由于每个操作都有自己的线程，操作系统会把两个线程当作是互不相干的任务分别执行，这样就可能在没有把整个文件装入内存时统计字数。为解决此问题，你必须使两个线程同步工作。
　　存在一些线程同步地址的问题，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位整数时原子的, 你可以依靠这一点完成互斥的方法. 对于能够产生全局名称的方法能够可以在进程间同步上(如互斥对象), 也可以用在线程间同步上;不能够产生全局名称的方法(如临界区)只能用在线程间同步上.

在编写多线程应用程序时，最重要的是控制好线程间的同步资源访问，以保证线程的安全运行。Win 32 API提供了一组同步对象，如：信号灯(Semaphore)、互斥（Mutex）、临界区（CriticalSection）和事件(Event)等，用来解决这个问题。

　　Delphi分别将事件对象和临界区对象封装为Tevent对象和TcritialSection对象，使得这两个对象的使用简单且方便。但是如果在Delphi程序中要使用信号灯或互斥等对象就必须借助于复杂的Win32 API函数，这对那些不熟悉Win32 API函数的编程人员来说很不方便。因此，笔者用Delphi构造了两个类,对信号灯和互斥对象进行了封装（分别为TSemaphore和TMutex），希望对广大Delphi编程人员有所帮助。

　　一、类的构造
　　我们先对Win32 API的信号灯对象和互斥对象进行抽象，构造一个父类THandleObjectEx，然后由这个父类派生出两个子类Tsemphore和Tmutex。

　　类的源代码如下：

　　unit SyncobjsEx;

　　interface

　　uses Windows,Messages,SysUtils,Classes,Syncobjs;

　　type

　　 THandleObjectEx = class(THandleObject)

　　// THandleObjectEx为互斥类和信号灯类的父类

　　 protected

　　 FHandle: THandle;

　　 FLastError: Integer;

　　 public

　　 destructor Destroy; override;

　　 procedure Release;override;

　　 function WaitFor(Timeout: DWORD): TWaitResult;

　　 property LastError:Integer read FLastError;

　　 property Handle: THandle read FHandle;

　　 end;

　　 TMutex = class(THandleObjectEx)//互斥类

　　 public

　　 constructor Create(MutexAttributes: PSecurityAttributes; InitialOwner: Boolean;const Name:string);

　　 procedure Release; override;

　　 end;

　　 TSemaphore = class(THandleObjectEx)

　　//信号灯类

　　public

　　constructor Create(SemaphoreAttributes: PSecurityAttributes;InitialCount:Integer;MaximumCount: integer; const Name: string);

　　procedure Release(ReleaseCount: Integer=1;PreviousCount:Pointer=nil)；overload;

　　 end;

　　implementation

　　{ THandleObjectEx }//父类的实现

　　destructor THandleObjectEx.Destroy;

　　begin

　　 Windows.CloseHandle(FHandle);

　　 inherited Destroy;

　　end;

　　procedure THandleObjectEx.Release;

　　begin

　　end;

　　function THandleObjectEx.WaitFor(Timeout: DWORD): TWaitResult;

　　//等待函数，参数为等待时间

　　begin

　　case WaitForSingleObject(Handle, Timeout) of

　　WAIT_ABANDONED: Result := wrAbandoned;

　　//无信号

　　WAIT_OBJECT_0: Result := wrSignaled;

　　//有信号

　　WAIT_TIMEOUT: Result := wrTimeout;//超时

　　WAIT_FAILED://失败

　　 begin

　　 Result := wrError;

　　 FLastError := GetLastError;

　　 end;

　　 else

　　 Result := wrError;

　　 end;

　　end;

　　{ TSemaphore }//信号灯类的实现

　　constructor TSemaphore.Create(SemaphoreAttributes: PSecurityAttributes;

　　 InitialCount, MaximumCount: integer; const Name: string);//信号灯类的构造函数

　　begin

　　FHandle := CreateSemaphore

　　(SemaphoreAttributes,InitialCount,

　　MaximumCount,PChar(Name));

　　//四个参数分别为：安全属性、初始信号灯计数、最大信号灯计数、信号灯名字

　　end;

　　procedure TSemaphore.Release(ReleaseCount: Integer=1; PreviousCount: Pointer=nil);

　　//信号灯类的Release方法，每执行一次按指定量增加信号灯计数

　　begin

　　 Windows.ReleaseSemaphore(FHandle, ReleaseCount, PreviousCount);

　　end;

　　{ TMutex }//互斥类的实现

　　constructor TMutex.Create(MutexAttributes: PSecurityAttributes;

　　InitialOwner: Boolean; const Name: string);

　　//互斥类的构造函数

　　begin

　　 FHandle := CreateMutex(MutexAttributes, InitialOwner, PChar(Name));

　　end;

　　procedure TMutex.Release;//互斥类的Release方法，用来释放对互斥对象的所有权

　　begin

　　 Windows.ReleaseMutex(FHandle);

　　end;

　　end.

　　二、信号灯对象与互斥对象的使用
　　1. 信号灯对象

　　信号灯对象维持一个从0到指定最大值之间的数。在其计数大于0时是有信号的，而在其计数为0时是无信号的。信号灯对象可用来限制对共享资源进行访问的线程数量，例如应用程序可使用信号灯对象来限制它建立的窗口数量。

　　用类的Create方法来建立信号灯对象，在调用该方法时，可以指定对象的初始计数和最大计数。该方法有四个参数，依次为：安全属性、初始计数、最大计数和对象名字（以便别的进程的线程可打开指定名字的信号灯句柄）。如：

　　Semaphore := TSemaphore.Create(nil,10,10,'');

　　一般把信号灯的初始计数设置成最大值。每次当信号灯有信号并等待函数返回时，信号灯计数就会减1，而通过调用对象的Release方法可按指定量增加信号灯的计数（默认为加1）。计数值越小就表明访问共享资源的程序越多。如：“Semaphore.Release(3, nil);”，其中第一个参数为增加的信号灯数量，第二个参数为执行该方法之前的信号灯数量。信号灯用法举例：

　　if wrSignaled = Semaphore.WaitFor(10000) then//若信号灯是有信号的

　　begin

　　 //打开另一个窗口

　　end

　　 Semaphore.Release()

　　在线程建立窗口之前，它使用WaitFor函数确定信号灯的当前计数是否允许建立新的窗口，等待时间设为10秒。

　　2. 互斥对象

　　Mutex对象的状态在它不被任何线程拥有时是有信号的，而当它被拥有时则是无信号的。Mutex对象很适合用来协调多个线程对共享资源的互斥访问(mutually exclusive)。例如，有几个线程共享对数据库的访问时，线程可以使用Mutex对象，一次只允许一个线程向数据库写入。

　　用类的Create方法建立Mutex 对象，在建立Mutex 时，可以为对象起个名字，这样其他进程中的线程可以打开指定名字的Mutex对象句柄。例如：

　　Mutex := TMutex.Create(nil, False, '');

　　在完成对共享资源的访问后，可以调用Release方法来释放Mutex，以便让别的线程能访问共享资源。如果线程终止而不释放Mutex，则认为该Mutex被废弃。

　　互斥对象用法举例如下：

　　if wrSignaled = Mutex.WaitFor(10000) then//若获得互斥对象的拥有权

　　 begin

　　 try

　　 //往数据库写入

　　 finally

　　Mutex.Release;//释放对互斥对象的拥有权

　　 end;

　　 end;

posted @ 2019-11-06 15:09 木头侠阅读(464) 评论(0) 编辑收藏举报

刷新页面返回顶部

木头侠

Delphi 中多线程同步的一些处理方法

公告