关于线程同步的一些方法
2006-02-04 13:33:38 来源：WEB开发网核心提示：线程是进程内一个相对独立的、可调度的执行单元，一个应用可以有一个主线程，关于线程同步的一些方法，一个主线程可以有多个子线程，子线程还可以有自己的子线程，并且多个线程同时访问一个共享资源或数据时，你需要考虑线程同步的问题了，这样就构成了多线程应用了，由于多个线程往往会同时访问同一块内存区域
线程是进程内一个相对独立的、可调度的执行单元。一个应用可以有一个主线程，一个主线程可以有多个子线程，子线程还可以有自己的子线程，这样就构成了多线程应用了。由于多个线程往往会同时访问同一块内存区域，频繁的访问这块区域，将会增加产生线程冲突的概率。一旦产生了冲突，将会造成不可预料的结果（该公用区域的值是不可预料的）可见处理线程同步的必要性。
注意：本文中出现的所有代码都是用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:=
//在窗体销毁中
CloseHandle(hSemaphore)
//在线程中
WaitForSingleObject(hSemaphore,INFINITE)
……保护的代码
ReleaseSemaphore(hSemaphore, lReleaseCount, lpPreviousCount) 4. 还可以使用Delphi中的TcriticalSection这个VCL对象，它的定义在Syncobjs.pas中。 当你开发多线程应用时，并且多个线程同时访问一个共享资源或数据时，你需要考虑线程同步的问题了。 如果你想获得本文的电子版及其源代码，那么请到http://codehunter.1yes.net 网站上下载.
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中。 当你开发多线程应用时，并且多个线程同时访问一个共享资源或数据时，你需要考虑线程同步的问题了。 如果你想获得本文的电子版及其源代码，那么请到http://codehunter.1yes.net 网站上下载.
中查找“关于线程同步的一些方法”更多相关内容
中查找“关于线程同步的一些方法”更多相关内容更多精彩
赞助商链接
