c++多线程编程之四——线程的同步

c++多线程编程之四——线程的同步
c++多线程编程之四——线程的同步

八、线程的同步

虽然多线程能给我们带来好处,但是也有不少问题需要解决。例如,对于像磁盘驱动器这样独占性系统资源,由于线程可以执行进程的任何代码段,且线程的运行是由系统调度自动完成的,具有一定的不确定性,因此就有可能出现两个线程同时对磁盘驱动器进行操作,从而出现操作错误;又例如,对于银行系统的计算机来说,可能使用一个线程来更新其用户数据库,而用另外一个线程来读取数据库以响应储户的需要,极有可能读数据库的线程读取的是未完全更新的数据库,因为可能在读的时候只有一部分数据被更新过。

使隶属于同一进程的各线程协调一致地工作称为线程的同步。MFC提供了多种同步对象,下面我们只介绍最常用的四种:

?临界区(CCriticalSection)

?事件(CEvent)

?互斥量(CMutex)

?信号量(CSemaphore)

通过这些类,我们可以比较容易地做到线程同步。

A、使用CCriticalSection 类

当多个线程访问一个独占性共享资源时,可以使用“临界区”对象。任一时刻只有一个线程可以拥有临界区对象,拥有临界区的线程可以访问被保护起来的资源或代码段,其他希望进入临界区的线程将被挂起等待,直到拥有临界区的线程放弃临界区时为止,这样就保证了不会在同一时刻出现多个线程访问共享资源。

CCriticalSection类的用法非常简单,步骤如下:

1.定义CCriticalSection类的一个全局对象(以使各个线程均能访问),如

CCriticalSection critical_section;

2.在访问需要保护的资源或代码之前,调用CCriticalSection类的成员Lock

()获得临界区对象:

3.critical_section.Lock();

在线程中调用该函数来使线程获得它所请求的临界区。如果此时没有其它线程占有临界区对象,则调用Lock()的线程获得临界区;否则,线程将被

挂起,并放入到一个系统队列中等待,直到当前拥有临界区的线程释放了

临界区时为止。

4.访问临界区完毕后,使用CCriticalSection的成员函数Unlock()来释放临

界区:

5.critical_section.Unlock();

再通俗一点讲,就是线程A执行到critical_section.Lock();语句时,如果

其它线程(B)正在执行critical_section.Lock();语句后且critical_section.

Unlock();语句前的语句时,线程A就会等待,直到线程B执行完

critical_section. Unlock();语句,线程A才会继续执行。

下面再通过一个实例进行演示说明。

例程8 MultiThread8

1.建立一个基于对话框的工程MultiThread8,在对话框

IDD_MULTITHREAD8_DIALOG中加入两个按钮和两个编辑框控件,两个

按钮的ID分别为IDC_WRITEW和IDC_WRITED,标题分别为“写…W?”和“写

…D?”;两个编辑框的ID分别为IDC_W和IDC_D,属性都选中Read-only;

2.在MultiThread8Dlg.h文件中声明两个线程函数:

3.UINT WriteW(LPVOID pParam);

4.UINT WriteD(LPVOID pParam);

5.使用ClassWizard分别给IDC_W和IDC_D添加CEdit类变量m_ctrlW和

m_ctrlD;

6.在MultiThread8Dlg.cpp文件中添加如下内容:

为了文件中能够正确使用同步类,在文件开头添加:

7.#include "afxmt.h"

定义临界区和一个字符数组,为了能够在不同线程间使用,定义为全局变

量:

CCriticalSection critical_section;

char g_Array[10];

添加线程函数:

UINT WriteW(LPVOID pParam)

{

CEdit *pEdit=(CEdit*)pParam;

pEdit->SetWindowText("");

critical_section.Lock();

//锁定临界区,其它线程遇到critical_section.Lock();语句时要等待

//直至执行critical_section.Unlock();语句

for(int i=0;i<10;i++)

{

g_Array[i]=''W'';

pEdit->SetWindowText(g_Array);

Sleep(1000);

}

critical_section.Unlock();

return 0;

}

UINT WriteD(LPVOID pParam)

{

CEdit *pEdit=(CEdit*)pParam;

pEdit->SetWindowText("");

critical_section.Lock();

//锁定临界区,其它线程遇到critical_section.Lock();语句时要等待

//直至执行critical_section.Unlock();语句

for(int i=0;i<10;i++)

{

g_Array[i]=''D'';

pEdit->SetWindowText(g_Array);

Sleep(1000);

}

critical_section.Unlock();

return 0;

}

8.分别双击按钮IDC_WRITEW和IDC_WRITED,添加其响应函数:

9.void CMultiThread8Dlg::OnWritew()

10.{

11.CWinThread *pWriteW=AfxBeginThread(WriteW,

12.&m_ctrlW,

13.THREAD_PRIORITY_NORMAL,

14.0,

15.CREATE_SUSPENDED);

16.pWriteW->ResumeThread();

17.}

18.

19.void CMultiThread8Dlg::OnWrited()

20.{

21.CWinThread *pWriteD=AfxBeginThread(WriteD,

22.&m_ctrlD,

23.THREAD_PRIORITY_NORMAL,

24.0,

25.CREATE_SUSPENDED);

26.pWriteD->ResumeThread();

27.

}

由于代码较简单,不再详述。编译、运行该例程,您可以连续点击两个按钮,观察体会临界类的作用。

B、使用CEvent 类

CEvent 类提供了对事件的支持。事件是一个允许一个线程在某种情况发生时,唤醒另外一个线程的同步对象。例如在某些网络应用程序中,一个线程(记为A)负责监听通讯端口,另外一个线程(记为B)负责更新用户数据。通过使用CEvent 类,线程A可以通知线程B何时更新用户数据。每一个CEvent 对象可以有两种状态:有信号状态和无信号状态。线程监视位于其中的CEvent 类对象的状态,并在相应的时候采取相应的操作。

在MFC中,CEvent 类对象有两种类型:人工事件和自动事件。一个自动CEvent 对象在被至少一个线程释放后会自动返回到无信号状态;而人工事件对象获得信号后,释放可利用线程,但直到调用成员函数ReSetEvent()才将其设置为无信号状态。在创建CEvent 类的对象时,默认创建的是自动事件。CEvent 类的各成员函数的原型和参数说明如下:

1、CEvent(BOOL bInitiallyOwn=FALSE,

BOOL bManualReset=FALSE,

LPCTSTR lpszName=NULL,

LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);

?bInitiallyOwn:指定事件对象初始化状态,TRUE为有信号,FALSE为无信号;

?bManualReset:指定要创建的事件是属于人工事件还是自动事件。TRUE 为人工事件,FALSE为自动事件;

?后两个参数一般设为NULL,在此不作过多说明。

2、BOOL CEvent::SetEvent();

将CEvent 类对象的状态设置为有信号状态。如果事件是人工事件,则CEvent 类对象保持为有信号状态,直到调用成员函数ResetEvent()将其重新设为无信号状态时为止。如果CEvent 类对象为自动事件,则在SetEvent()将事件设置为有信号状态后,CEvent 类对象由系统自动重置为无信号状态。

如果该函数执行成功,则返回非零值,否则返回零。

3、BOOL CEvent::ResetEvent();

该函数将事件的状态设置为无信号状态,并保持该状态直至SetEvent()被调用时为止。由于自动事件是由系统自动重置,故自动事件不需要调用该函数。如果该函数执行成功,返回非零值,否则返回零。我们一般通过调用WaitForSingleObject函数来监视事件状态。前面我们已经介绍了该函数。由于语言描述的原因,CEvent 类的理解确实有些难度,但您只要通过仔细玩味下面例程,多看几遍就可理解。

例程9 MultiThread9

1.建立一个基于对话框的工程MultiThread9,在对话框

IDD_MULTITHREAD9_DIALOG中加入一个按钮和两个编辑框控件,按钮的ID为IDC_WRITEW,标题为“写…W?”;两个编辑框的ID分别为IDC_W 和IDC_D,属性都选中Read-only;

2.在MultiThread9Dlg.h文件中声明两个线程函数:

3.UINT WriteW(LPVOID pParam);

4.UINT WriteD(LPVOID pParam);

5.使用ClassWizard分别给IDC_W和IDC_D添加CEdit类变量m_ctrlW和

m_ctrlD;

6.在MultiThread9Dlg.cpp文件中添加如下内容:

为了文件中能够正确使用同步类,在文件开头添加

#include "afxmt.h"

定义事件对象和一个字符数组,为了能够在不同线程间使用,定义为全局变量。

CEvent eventWriteD;

char g_Array[10];

添加线程函数:

UINT WriteW(LPVOID pParam)

{

CEdit *pEdit=(CEdit*)pParam;

pEdit->SetWindowText("");

for(int i=0;i<10;i++)

{

g_Array[i]=''W'';

pEdit->SetWindowText(g_Array);

Sleep(1000);

}

eventWriteD.SetEvent();

return 0;

}

UINT WriteD(LPVOID pParam)

{

CEdit *pEdit=(CEdit*)pParam;

pEdit->SetWindowText("");

WaitForSingleObject(eventWriteD.m_hObject,INFINITE);

for(int i=0;i<10;i++)

{

g_Array[i]=''D'';

pEdit->SetWindowText(g_Array);

Sleep(1000);

}

return 0;

}

仔细分析这两个线程函数, 您就会正确理解CEvent 类。线程WriteD 执行到WaitForSingleObject(eventWriteD.m_hObject,INFINITE);处等

待,直到事件eventWriteD为有信号该线程才往下执行,因为eventWriteD 对象是自动事件,则当WaitForSingleObject()返回时,系统自动把

eventWriteD对象重置为无信号状态。

7.双击按钮IDC_WRITEW,添加其响应函数:

8.void CMultiThread9Dlg::OnWritew()

9.{

10.CWinThread *pWriteW=AfxBeginThread(WriteW,

11.&m_ctrlW,

12.THREAD_PRIORITY_NORMAL,

13.0,

14.CREATE_SUSPENDED);

15.pWriteW->ResumeThread();

16.

17.CWinThread *pWriteD=AfxBeginThread(WriteD,

18.&m_ctrlD,

19.THREAD_PRIORITY_NORMAL,

20.0,

21.CREATE_SUSPENDED);

22.pWriteD->ResumeThread();

23.

}

编译并运行程序,单击“写…W?”按钮,体会事件对象的作用。

C、使用CMutex 类

互斥对象与临界区对象很像.互斥对象与临界区对象的不同在于:互斥对象

可以在进程间使用,而临界区对象只能在同一进程的各线程间使用。当然,互斥对象也可以用于同一进程的各个线程间,但是在这种情况下,使用临界区会更节省系统资源,更有效率。

D、使用CSemaphore 类

当需要一个计数器来限制可以使用某个线程的数目时,可以使用“信号量”

对象。CSemaphore 类的对象保存了对当前访问某一指定资源的线程的计数值,该计数值是当前还可以使用该资源的线程的数目。如果这个计数达到了零,则所有对这个CSemaphore 类对象所控制的资源的访问尝试都被放入到一个队列中

等待,直到超时或计数值不为零时为止。一个线程被释放已访问了被保护的资源时,计数值减1;一个线程完成了对被控共享资源的访问时,计数值增1。这个被CSemaphore 类对象所控制的资源可以同时接受访问的最大线程数在该对象的构建函数中指定。

CSemaphore 类的构造函数原型及参数说明如下:

CSemaphore (LONG lInitialCount=1,

LONG lMaxCount=1,

LPCTSTR pstrName=NULL,

LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);

?lInitialCount:信号量对象的初始计数值,即可访问线程数目的初始值;

?lMaxCount:信号量对象计数值的最大值,该参数决定了同一时刻可访问由信号量保护的资源的线程最大数目;

?后两个参数在同一进程中使用一般为NULL,不作过多讨论;

在用CSemaphore 类的构造函数创建信号量对象时要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数,每增加一个线程对共享资源的访问,当前可用资源计数就会减1,只要当前可用资源计数是大于0的,就可以发出信号量信号。但是当前可用计数减小到0时,则说明当前占用资源的线程数已经达到了所允许的最大数目,不能再允许其它线程的进入,此时的信号量信号将无法发出。线程在处理完共享资源后,应在离开的同时通过ReleaseSemaphore()函数将当前可用资源数加1。

下面给出一个简单实例来说明CSemaphore 类的用法。

例程10 MultiThread10

1.建立一个基于对话框的工程MultiThread10,在对话框

IDD_MULTITHREAD10_DIALOG中加入一个按钮和三个编辑框控件,按钮的ID为IDC_START,标题为“同时写…A?、…B?、…C?”;三个编辑框的ID分别为IDC_A、IDC_B和IDC_C,属性都选中Read-only;

2.在MultiThread10Dlg.h文件中声明两个线程函数:

3.UINT WriteA(LPVOID pParam);

4.UINT WriteB(LPVOID pParam);

UINT WriteC(LPVOID pParam);

5.使用ClassWizard分别给IDC_A、IDC_B和IDC_C添加CEdit类变量

m_ctrlA、m_ctrlB和m_ctrlC;

6.在MultiThread10Dlg.cpp文件中添加如下内容:

为了文件中能够正确使用同步类,在文件开头添加:

#include "afxmt.h"

定义信号量对象和一个字符数组,为了能够在不同线程间使用,定义为全局变量:

CSemaphore semaphoreWrite(2,2); //资源最多访问线程2个,当前可访问线程数2个

char g_Array[10];

添加三个线程函数:

UINT WriteA(LPVOID pParam)

{

CEdit *pEdit=(CEdit*)pParam;

pEdit->SetWindowText("");

WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE) ;

CString str;

for(int i=0;i<10;i++)

{

pEdit->GetWindowText(str);

g_Array[i]=''A'';

str=str+g_Array[i];

pEdit->SetWindowText(str);

Sleep(1000);

}

ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);

return 0;

}

UINT WriteB(LPVOID pParam)

{

CEdit *pEdit=(CEdit*)pParam;

pEdit->SetWindowText("");

WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE) ;

CString str;

for(int i=0;i<10;i++)

{

pEdit->GetWindowText(str);

g_Array[i]=''B'';

str=str+g_Array[i];

pEdit->SetWindowText(str);

Sleep(1000);

}

ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);

return 0;

}

UINT WriteC(LPVOID pParam)

{

CEdit *pEdit=(CEdit*)pParam;

pEdit->SetWindowText("");

WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE) ;

for(int i=0;i<10;i++)

{

g_Array[i]=''C'';

pEdit->SetWindowText(g_Array);

Sleep(1000);

}

ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);

return 0;

}

这三个线程函数不再多说。在信号量对象有信号的状态下,线程执行到WaitForSingleObject语句处继续执行,同时可用线程数减1;若线程执行到WaitForSingleObject语句时信号量对象无信号,线程就在这里等待,直到信号量对象有信号线程才往下执行。

7.双击按钮IDC_START,添加其响应函数:

8.void CMultiThread10Dlg::OnStart()

9.{

10.CWinThread *pWriteA=AfxBeginThread(WriteA,

11.&m_ctrlA,

12.THREAD_PRIORITY_NORMAL,

13.0,

14.CREATE_SUSPENDED);

15.pWriteA->ResumeThread();

16.

17.CWinThread *pWriteB=AfxBeginThread(WriteB,

18.&m_ctrlB,

19.THREAD_PRIORITY_NORMAL,

20.0,

21.CREATE_SUSPENDED);

22.pWriteB->ResumeThread();

23.

24.CWinThread *pWriteC=AfxBeginThread(WriteC,

25.&m_ctrlC,

26.THREAD_PRIORITY_NORMAL,

27.0,

28.CREATE_SUSPENDED);

29.pWriteC->ResumeThread();

30.

31.

32.}

好吧,多线程编程就介绍到这里,希望本文能对您有所帮助。

解决多线程中11个常见问题

并发危险 解决多线程代码中的11 个常见的问题 Joe Duffy 本文将介绍以下内容:?基本并发概念 ?并发问题和抑制措施 ?实现安全性的模式?横切概念本文使用了以下技术: 多线程、.NET Framework 目录 数据争用 忘记同步 粒度错误 读写撕裂 无锁定重新排序 重新进入 死锁 锁保护 戳记 两步舞曲 优先级反转 实现安全性的模式 不变性 纯度 隔离 并发现象无处不在。服务器端程序长久以来都必须负责处理基本并发编程模型,而随着多核处理器的日益普及,客户端程序也将需要执行一些任务。随着并发操作的不断增加,有关确保安全的问题也浮现出来。也就是说,在面对大量逻辑并发操作和不断变化的物理硬件并行性程度时,程序必须继续保持同样级别的稳定性和可靠性。 与对应的顺序代码相比,正确设计的并发代码还必须遵循一些额外的规则。对内存的读写以及对共享资源的访问必须使用同步机制进行管制,以防发生冲突。另外,通常有必要对线程进行协调以协同完成某项工作。 这些附加要求所产生的直接结果是,可以从根本上确保线程始终保持一致并且保证其顺利向前推进。同步和协调对时间的依赖性很强,这就导致了它们具有不确定性,难于进行预测和测试。 这些属性之所以让人觉得有些困难,只是因为人们的思路还未转变过来。没有可供学习的专门API,也没有可进行复制和粘贴的代码段。实际上的确有一组基础概念需要您学习和适应。很可能随着时间的推移某些语言和库会隐藏一些概念,但如果您现在就开始执行并发操作,则不会遇到这种情况。本

文将介绍需要注意的一些较为常见的挑战,并针对您在软件中如何运用它们给出一些建议。 首先我将讨论在并发程序中经常会出错的一类问题。我把它们称为“安全隐患”,因为它们很容易发现并且后果通常比较严重。这些危险会导致您的程序因崩溃或内存问题而中断。 当从多个线程并发访问数据时会发生数据争用(或竞争条件)。特别是,在一个或多个线程写入一段数据的同时,如果有一个或多个线程也在读取这段数据,则会发生这种情况。之所以会出现这种问题,是因为Windows 程序(如C++ 和Microsoft .NET Framework 之类的程序)基本上都基于共享内存概念,进程中的所有线程均可访问驻留在同一虚拟地址空间中的数据。静态变量和堆分配可用于共享。请考虑下面这个典型的例子: static class Counter { internal static int s_curr = 0; internal static int GetNext() { return s_curr++; } } Counter 的目标可能是想为GetNext 的每个调用分发一个新的唯一数字。但是,如果程序中的两个线程同时调用GetNext,则这两个线程可能被赋予相同的数字。原因是s_curr++ 编译包括三个独立的步骤: 1.将当前值从共享的s_curr 变量读入处理器寄存器。 2.递增该寄存器。 3.将寄存器值重新写入共享s_curr 变量。 按照这种顺序执行的两个线程可能会在本地从s_curr 读取了相同的值(比如42)并将其递增到某个值(比如43),然后发布相同的结果值。这样一来,GetNext 将为这两个线程返回相同的数字,导致算法中断。虽然简单语句s_curr++ 看似不可分割,但实际却并非如此。 忘记同步 这是最简单的一种数据争用情况:同步被完全遗忘。这种争用很少有良性的情况,也就是说虽然它们是正确的,但大部分都是因为这种正确性的根基存在问题。 这种问题通常不是很明显。例如,某个对象可能是某个大型复杂对象图表的一部分,而该图表恰好可使用静态变量访问,或在创建新线程或将工作排入线程池时通过将某个对象作为闭包的一部分进行传递可变为共享图表。 当对象(图表)从私有变为共享时,一定要多加注意。这称为发布,在后面的隔离上下文中会对此加以讨论。反之称为私有化,即对象(图表)再次从共享变为私有。 对这种问题的解决方案是添加正确的同步。在计数器示例中,我可以使用简单的联锁: static class Counter { internal static volatile int s_curr = 0; internal static int GetNext() { return Interlocked.Increment(ref s_curr);

实验2-2windows2000 线程同步

实验2 并发与调度 2.2 Windows 2000线程同步 (实验估计时间:120分钟) 背景知识 实验目的 工具/准备工作 实验内容与步骤 背景知识 Windows 2000提供的常用对象可分成三类:核心应用服务、线程同步和线程间通讯。其中,开发人员可以使用线程同步对象来协调线程和进程的工作,以使其共享信息并执行任务。此类对象包括互锁数据、临界段、事件、互斥体和信号等。 多线程编程中关键的一步是保护所有的共享资源,工具主要有互锁函数、临界段和互斥体等;另一个实质性部分是协调线程使其完成应用程序的任务,为此,可利用内核中的事件对象和信号。 在进程内或进程间实现线程同步的最方便的方法是使用事件对象,这一组内核对象允许一个线程对其受信状态进行直接控制 (见表4-1) 。 而互斥体则是另一个可命名且安全的内核对象,其主要目的是引导对共享资源的访问。拥有单一访问资源的线程创建互斥体,所有想要访问该资源的线程应该在实际执行操作之前获得互斥体,而在访问结束时立即释放互斥体,以允许下一个等待线程获得互斥体,然后接着进行下去。 与事件对象类似,互斥体容易创建、打开、使用并清除。利用CreateMutex() API 可创建互斥体,创建时还可以指定一个初始的拥有权标志,通过使用这个标志,只有当线程完成了资源的所有的初始化工作时,才允许创建线程释放互斥体。

为了获得互斥体,首先,想要访问调用的线程可使用OpenMutex() API来获得指向对象的句柄;然后,线程将这个句柄提供给一个等待函数。当内核将互斥体对象发送给等待线程时,就表明该线程获得了互斥体的拥有权。当线程获得拥有权时,线程控制了对共享资源的访问——必须设法尽快地放弃互斥体。放弃共享资源时需要在该对象上调用ReleaseMute() API。然后系统负责将互斥体拥有权传递给下一个等待着的线程(由到达时间决定顺序) 。 实验目的 在本实验中,通过对事件和互斥体对象的了解,来加深对Windows 2000线程同步的理解。 1) 回顾系统进程、线程的有关概念,加深对Windows 2000线程的理解。 2) 了解事件和互斥体对象。 3) 通过分析实验程序,了解管理事件对象的API。 4) 了解在进程中如何使用事件对象。 5) 了解在进程中如何使用互斥体对象。 6) 了解父进程创建子进程的程序设计方法。 工具/准备工作 在开始本实验之前,请回顾教科书的相关内容。 您需要做以下准备: 1) 一台运行Windows 2000 Professional操作系统的计算机。 2) 计算机中需安装Visual C++ 6.0专业版或企业版。 实验内容与步骤 1. 事件对象 2. 互斥体对象 1. 事件对象 清单2-1程序展示了如何在进程间使用事件。父进程启动时,利用CreateEvent() API创建一个命名的、可共享的事件和子进程,然后等待子进程向事件发出信号并终止父进程。在创建时,子进程通过OpenEvent() API打开事件对象,调用SetEvent() API使其转化为已接受信号状态。两个进程在发出信号之后几乎立即终止。 步骤1:登录进入Windows 2000 Professional。 步骤2:在“开始”菜单中单击“程序”-“Microsoft Visual Studio 6.0”–“Microsoft Visual C++ 6.0”命令,进入Visual C++窗口。

Java_2实用教程第4版_第12章_Java多线程机制

2014/1/20 第 1 页 注意:开始用功了! 1 2014/1/20 第 2 页 《Java2实用教程(第4版)》第12章 配合例子源代码一起使用 Power point 制作:耿祥义张跃平 Java多线程机制 2 2014/1/20 第 3 页 导读 主要内容 Java中的线程 Thread类与线程的创建 线程的常用方法 线程同步 协调同步的线程 线程联合 GUI线程 计时器线程 3 2014/1/20 第 4 页 §12.1 进程与线程 §12.1.1 操作系统与进程 程序是一段静态的代码,它是应用软件执行的蓝本。 进程是程序的一次动态执行过程,它对应了从代码加载、执行至执行完毕的一个完整过程,这个过程也是进程本身从产生、发展至消亡的过程。 现代操作系统可以同时管理一个计算机系统中的多个进程,即可以让计算机系统中的多个进程轮流使用CPU资源。 4 2014/1/20 第 5 页 §12.1.2 进程与线程 线程是比进程更小的执行单位,一个进程在其执行过程中,可以产生多个线程,形成多条执行线索,每条线索,即每个线程也有它自身的产生、存在和消亡的过程。 线程间可以共享进程中的某些内存单元(包括代码与数据),线程的中断与恢复可以更加节省系统的开销。 5 2014/1/20 第 6 页

§12.2 Java中的线程 §12.2.1 Java的多线程机制 Java语言的一大特性点就是内置对多线程的支持。 Java虚拟机快速地把控制从一个线程切换到另一个线程。这些线程将被轮流执行,使得每个线程都有机会使用CPU资源。 6 2014/1/20 第7 页 §12.2.2 主线程(main线程) 每个Java应用程序都有一个缺省的主线程。 当JVM(Java Virtual Machine 虚拟机)加载代码,发现main方法之后,就会启动一个线程,这个线程称为“主线程”(main线程),该线程负责执行main方法。 JVM一直要等到Java应用程序中的所有线程都结束之后,才结束Java应用程序。 7 2014/1/20 第8 页 §12.2.3 线程的状态与生命周期 建的线程在它的一个完整的生命周期中通常要经历如下的四种状态: 1.新建: 当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态。2.运行:线程必须调用start()方法(从父类继承的方法)通知JVM,这样JVM就会知道又有一个新一个线程排队等候切换了。一旦轮到它来享用CPU资源时,此线程的就可以脱离创建它的主线程独立开始自己的生命周期了。 3.中断:有4种原因的中断: ◆JVM将CPU资源从当前线程切换给其他线程,使本线程让出CPU的使用权处于中断状态。 ◆线程使用CPU资源期间,执行了sleep(int millsecond)方法,使当前线程进入休眠状。 ◆线程使用CPU资源期间,执行了wait()方法。 ◆线程使用CPU资源期间,执行某个操作进入阻塞状态。 4.死亡:处于死亡状态的线程不具有继续运行的能力。线程释放了实体。 8 2014/1/20 第9 页 例子1(Example12_1.java )通过分析运行结果阐述线程的4种状态。例子1在主线程中用Thread的子类创建了两个线程(SpeakElephant.java , SpeakCar.java ),这两个线程分别在命令行窗口输出20句“大象”和“轿车”;主线程在命令行窗口输出15句“主人”。 例子1的运行效果如图12.4。 例子1在不同的计算机运行或在同一台计算机反复运行的结果不尽相同,输出结果依赖当前CPU资源的使用情况。 9 2014/1/20 第10 页 §12.2.4 线程调度与优先级 处于就绪状态的线程首先进入就绪队列排队等候CPU资源,同一时刻在就绪队列中的线程可能有多个。Java虚拟机(JVM)中的线程调度器负责管理线程,调度器把线程的优先

4:一个经典的多线程同步问题汇总

一个经典的多线程同步问题 程序描述: 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求: 1.子线程输出的线程序号不能重复。 2.全局变量的输出必须递增。 下面画了个简单的示意图: 分析下这个问题的考察点,主要考察点有二个: 1.主线程创建子线程并传入一个指向变量地址的指针作参数,由于线程启动须要花费一定的时间,所以在子线程根据这个指针访问并保存数据前,主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2.子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架,可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include #include #include long g_nNum; //全局资源 unsigned int__stdcall Fun(void *pPM); //线程函数 const int THREAD_NUM = 10; //子线程个数 int main() { g_nNum = 0;

HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的,所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果:

多线程同步操作多个窗口

多线程同步操作多个窗口 RunApp "notepad.exe" RunApp "notepad.exe" RunApp "notepad.exe" Delay 2000 Dimenv temp_Hwnd temp_Hwnd = 0 Dim str, arr, i str = Plugin.Window.Search("无标题- 记事本") arr = Split(str, "|") For i = 0 To UBound(arr) - 1 temp_Hwnd = Plugin.Window.FindEx(arr(i), 0, "Edit", 0) BeginThread WriteString While temp_Hwnd <> 0'判断多线程已经启动完毕,继续循环下一个。 Delay 500 Wend Next EndScript Function WriteString() Dim str, Hwnd Hwnd = temp_Hwnd temp_Hwnd = 0 Do str = WaitKey If Hwnd <> Plugin.Window.GetKeyFocusWnd Then Call Plugin.Bkgnd.KeyPress(Hwnd, str) End If Loop End Function 多线程多开窗口同步执行与子线程间的数值如何传递: 1.Dimenv IsThread, i 2.Dim arr_Thread() 3.For i = 0 To 2 4. IsThread = False'未启动线程 5. Redim Preserve arr_Thread(i) 6. arr_Thread(i) = BeginThread(EnterThread) 7. While IsThread = False'未启动成功,等待中 8. Delay 500 9. Wend 10. '跳出循环说明 IsThread = True,已经执行到了,循环继续启动下一个 11.Next

Java第七单元练习题 Java多线程机制

7Java多线程机制 7.1单项选择题 1. 线程调用了sleep()方法后,该线程将进入()状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程,下面说法错误的是() A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种:实现Runnable接口和继承Thread类 D. 新线程一旦被创建,它将自动开始运行 3. 在java中的线程模型包含() A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中,临界区可以是一个语句块,或者是一个方法,并用()关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中,yield()的作用是() A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中,对象的锁在()情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外(exception)时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下()情况下,线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时 C. 线程调用了yield()方法时 D. 以上都是 8. java用()机制实现了进程之间的异步执行 A. 监视器

B. 虚拟机 C. 多个CPU D. 异步调用 9.Thread类的方法中,toString()方法的作用是() A. 只返回线程的名称 B. 返回当前线程所属的线程组的名称 C. 返回当前线程对象 D. 返回线程的名称 10.Java语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点() A. 安全性 B. 多线程 C. 跨平台 D. 可移值 11.以下哪个关键字可以用来对对象加互斥锁() A. transient B. synchronized C. serialize D. static 12.下面关于进程、线程的说法不正确的是( )。 A.进程是程序的一次动态执行过程。一个进程在其执行过程中,可以产生多个线程——多线程,形成多条执行线索。 B.线程是比进程更小的执行单位,是在一个进程中独立的控制流,即程序内部的控制流。线程本身不能自动运行,栖身于某个进程之中,由进程启动执行。 C.Java多线程的运行与平台无关。 D.对于单处理器系统,多个线程分时间片获取CPU或其他系统资源来运行。对于多处理器系统,线程可以分配到多个处理器中,从而真正的并发执行多任务。 7.2填空题 1.________是java程序的并发机制,它能同步共享数据、处理不同的事件。 2.线程是程序中的一个执行流,一个执行流是由CPU运行程序的代码、__________所形 成的,因此,线程被认为是以CPU为主体的行为。 3.线程的终止一般可以通过两种方法实现:自然撤销或者是__________. 4.线程模型在java中是由__________类进行定义和描述的。 5.线程的创建有两种方法:实现_________接口和继承Thread类。 6.多线程程序设计的含义是可以将程序任务分成几个________的子任务。 7.按照线程的模型,一个具体的线程也是由虚拟的CPU、代码与数据组成,其中代码与数 据构成了___________,线程的行为由它决定。 8.ava中,新建的线程调用start()方法、如myThread.start(),将使线程的状态从New(新建状 态)转换为_________。 9.多线程是java程序的________机制,它能同步共享数据,处理不同事件。 10.进程是由代码、数据、内核状态和一组寄存器组成,而线程是表示程序运行状态的 ______,如程序计数器、栈指针以及堆栈组成。 11.Thread类提供了一系列基本线程控制方法,如果我们需要让与当前进程具有相同优先 级的线程也有运行的机会则可以调用________方法。 12.在多线程系统中,多个线程之间有________和互斥两种关系。 13. 在一个时间只能由一个线程访问的资源称为临界资源,访问临界资源的代码

用多线程同步方法解决生产者-消费者问题(操作系统课设)

. 题目用多线程同步方法解决生产者-消费 者问题(Producer-Consumer Problem) 学院计算机科学与技术学院 专业软件工程 班级 姓名 指导教师 年月日

目录 目录 (1) 课程设计任务书 (2) 正文 (2) 1.设计目的与要求 (2) 1.1设计目的 (2) 1.2设计要求 (2) 2.设计思想及系统平台 (2) 2.1设计思想 (2) 2.2系统平台及使用语言 (2) 3.详细算法描述 (3) 4.源程序清单 (5) 5.运行结果与运行情况 (10) 6.调试过程 (15) 7.总结 (15) 本科生课程设计成绩评定表 (16)

课程设计任务书 学生姓名:专业班级: 指导教师:工作单位:计算机科学与技术学院 题目: 用多线程同步方法解决生产者-消费者问题 (Producer-Consumer Problem) 初始条件: 1.操作系统:Linux 2.程序设计语言:C语言 3.有界缓冲区内设有20个存储单元,其初值为0。放入/取出的数据项按增序设定为1-20这20个整型数。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要 求) 1.技术要求: 1)为每个生产者/消费者产生一个线程,设计正确的同步算法 2)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的当前全部内容、当前指针位置和生产者/消费者线程的自定义标识符。 3)生产者和消费者各有两个以上。 4)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2.设计说明书内容要求: 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3)数据结构与模块说明(功能与流程图) 4)给出用户名、源程序名、目标程序名和源程序及其运行结果。(要注明存储各个程序及其运行结果的主机IP地址和目录。) 5)运行结果与运行情况 (提示: (1)有界缓冲区可用数组实现。 (2)编译命令可用:cc -lpthread -o 目标文件名源文件名 (3)多线程编程方法参见附件。) 3. 调试报告: 1)调试记录 2)自我评析和总结 上机时间安排: 18周一~ 五 08:0 - 12:00 指导教师签名:年月日

CWinForm多线程开发剖析

C# WinForm多线程开发 一Thread类库 Windows是一个多任务的系统,如果你使用的是windows 2000及其以上版本,你可以通过任务管理器查看当前系统运行的程序和进程。什么是进程呢?当一个程序开始运行时,它就是一个进程,进程所指包括运行中的程序和程序所使用到的内存和系统资源。而一个进程又是由多个线程所组成的,线程是程序中的一个执行流,每个线程都有自己的专有寄存器(栈指针、程序计数器等),但代码区是共享的,即不同的线程可以执行同样的函数。多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务,也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。 一关于Thread的说明 在.net framework class library中,所有与多线程机制应用相关的类都是放在System.Threading 命名空间中的。其中提供Thread类用于创建线程,ThreadPool类用于管理线程池等等,此外还提供解决了线程执行安排,死锁,线程间通讯等实际问题的机制。如果你想在你的应用程序中使用多线程,就必须包含这个类。Thread类有几个至关重要的方法,描述如下:Start():启动线程 Sleep(int):静态方法,暂停当前线程指定的毫秒数 Abort():通常使用该方法来终止一个线程 Suspend():该方法并不终止未完成的线程,它仅仅挂起线程,以后还可恢复。 Resume():恢复被Suspend()方法挂起的线程的执行 线程入口使程序知道该让这个线程干什么事,在C#中,线程入口是通过ThreadStart代理(delegate)来提供的,你可以把ThreadStart理解为一个函数指针,指向线程要执行的函数,当调用Thread.Start()方法后,线程就开始执行ThreadStart所代表或者说指向的函数。ThreadState在各种情况下的可能取值如下: Aborted:线程已停止 AbortRequested:线程的Thread.Abort()方法已被调用,但是线程还未停止 Background:线程在后台执行,与属性Thread.IsBackground有关 Running:线程正在正常运行 Stopped:线程已经被停止 StopRequested:线程正在被要求停止 Suspended:线程已经被挂起(此状态下,可以通过调用Resume()方法重新运行)SuspendRequested:线程正在要求被挂起,但是未来得及响应 Unstarted:未调用Thread.Start()开始线程的运行 WaitSleepJoin:线程因为调用了Wait(),Sleep()或Join()等方法处于封锁状态 二Winform中使用的thread 首先可以看看最直接的方法,也是.net 1.0下支持的方法。但请注意的是,此方法在.net 2.0以后就已经是一种错误的方法了。 [csharp] view plain copy 在CODE上查看代码片派生到我的代码片 public partial class Form1 : Form

四种进程或线程同步互斥的控制方法

四种进程或线程同步互斥的控制方法 1、临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。 2、互斥量:为协调共同对一个共享资源的单独访问而设计的。 3、信号量:为控制一个具有有限数量用户资源而设计。 4、事件:用来通知线程有一些事件已发生,从而启动后继任务的开始。 一临界区 临界区的使用在线程同步中应该算是比较简单,说它简单还是说它同后面讲到的其它方法相比更容易理解。举个简单的例子:比如说有一个全局变量(公共资源)两个线程都会对它进行写操作和读操作,如果我们在这里不加以控制,会产生意想不到的结果。假设线程A 正在把全局变量加1然后打印在屏幕上,但是这时切换到线程B,线程B又把全局变量加1然后又切换到线程A,这时候线程A打印的结果就不是程序想要的结果,也就产生了错误。解决的办法就是设置一个区域,让线程A在操纵全局变量的时候进行加锁,线程B如果想操纵这个全局变量就要等待线程A释放这个锁,这个也就是临界区的概念。 二互斥体 windows api中提供了一个互斥体,功能上要比临界区强大。也许你要问,这个东东和临界区有什么区别,为什么强大?它们有以下几点不一致: 1.critical section是局部对象,而mutex是核心对象。因此像waitforsingleobject是不可以等待临界区的。 2.critical section是快速高效的,而mutex同其相比要慢很多 3.critical section使用围是单一进程中的各个线程,而mutex由于可以有一个名字,因此它是可以应用于不同的进程,当然也可以应用于同一个进程中的不同线程。 4.critical section 无法检测到是否被某一个线程释放,而mutex在某一个线程结束之后会产生一个abandoned的信息。同时mutex只能被拥有它的线程释放。下面举两个应用mutex 的例子,一个是程序只能运行一个实例,也就是说同一个程序如果已经运行了,就不能再运行了;另一个是关于非常经典的哲学家吃饭问题的例子。 三事件 事件对象的特点是它可以应用在重叠I/O(overlapped I/0)上,比如说socket编程中有两种模型,一种是重叠I/0,一种是完成端口都是可以使用事件同步。它也是核心对象,因此可以被waitforsingleobje这些函数等待;事件可以有名字,因此可以被其他进程开启。 四信号量 semaphore的概念理解起来可能要比mutex还难,我先简单说一下创建信号量的函数,因为我在开始使用的时候没有很快弄清楚,可能现在还有理解不对的地方,如果有错误还是请大侠多多指教。 CreateSemaphore( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // SD LONG lInitialCount, // initial count LONG lMaximumCount, // maximum count LPCTSTR lpName // object name )

Windows下多线程同步机制

多线程同步机制 Critical section(临界区)用来实现“排他性占有”。适用范围是单一进程的各线程之间。它是: ·一个局部性对象,不是一个核心对象。 ·快速而有效率。 ·不能够同时有一个以上的critical section被等待。 ·无法侦测是否已被某个线程放弃。 Mutex Mutex是一个核心对象,可以在不同的线程之间实现“排他性占有”,甚至几十那些现成分属不同进程。它是: ·一个核心对象。 ·如果拥有mutex的那个线程结束,则会产生一个“abandoned”错误信息。 ·可以使用Wait…()等待一个mutex。 ·可以具名,因此可以被其他进程开启。 ·只能被拥有它的那个线程释放(released)。 Semaphore Semaphore被用来追踪有限的资源。它是: ·一个核心对象。 ·没有拥有者。 ·可以具名,因此可以被其他进程开启。 ·可以被任何一个线程释放(released)。 Ev ent Object Ev ent object通常使用于overlapped I/O,或用来设计某些自定义的同步对象。它是: ·一个核心对象。 ·完全在程序掌控之下。 ·适用于设计新的同步对象。 · “要求苏醒”的请求并不会被储存起来,可能会遗失掉。 ·可以具名,因此可以被其他进程开启。 Interlocked Variable 如果Interlocked…()函数被使用于所谓的spin-lock,那么他们只是一种同步机制。所谓spin-lock是一种busy loop,被预期在极短时间内执行,所以有最小的额外负担(overhead)。系统核心偶尔会使用他们。除此之外,interlocked variables主要用于引用技术。他们:·允许对4字节的数值有些基本的同步操作,不需动用到critical section或mutex之类。 ·在SMP(Symmetric Multi-Processors)操作系统中亦可有效运作。 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

C#的多线程机制探索

一.多线程的概念 Windows是一个多任务的系统,如果你使用的是windows 2000及其以上版本,你可以通过任务管理器查看当前系统运行的程序和进程。什么是进程呢?当一个程序开始运行时,它就是一个进程,进程所指包括运行中的程序和程序所使用到的内存和系统资源。而一个进程又是由多个线程所组成的,线程是程序中的一个执行流,每个线程都有自己的专有寄存器(栈指针、程序计数器等),但代码区是共享的,即不同的线程可以执行同样的函数。多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务,也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。浏览器就是一个很好的多线程的例子,在浏览器中你可以在下载JAVA小应用程序或图象的同时滚动页面,在访问新页面时,播放动画和声音,打印文件等。 多线程的好处在于可以提高CPU的利用率——任何一个程序员都不希望自己的程序很多时候没事可干,在多线程程序中,一个线程必须等待的时候,CPU可以运行其它的线程而不是等待,这样就大大提高了程序的效率。 然而我们也必须认识到线程本身可能影响系统性能的不利方面,以正确使用线程:?线程也是程序,所以线程需要占用内存,线程越多占用内存也越多 ?多线程需要协调和管理,所以需要CPU时间跟踪线程 ?线程之间对共享资源的访问会相互影响,必须解决竞用共享资源的问题 ?线程太多会导致控制太复杂,最终可能造成很多Bug 基于以上认识,我们可以一个比喻来加深理解。假设有一个公司,公司里有很多各司其职的职员,那么我们可以认为这个正常运作的公司就是一个进程,而公司里的职员就是线程。一个公司至少得有一个职员吧,同理,一个进程至少包含一个线程。在公司里,你可以一个职员干所有的事,但是效率很显然是高不起来的,一个人的公司也不可能做大;一个程序中也可以只用一个线程去做事,事实上,一些过时的语言如fortune,basic都是如此,但是象一个人的公司一样,效率很低,如果做大程序,效率更低——事实上现在几乎没有单线程的商业软件。公司的职员越多,老板就得发越多的薪水给他们,还得耗费大量精力去管理他们,协调他们之间的矛盾和利益;程序也是如此,线程越多耗费的资源也越多,需要CPU时间去跟踪线程,还得解决诸如死锁,同步等问题。总之,如果你不想你的公司被称为“皮包公司”,你就得多几个员工;如果你不想让你的程序显得稚气,就在你的程序里引入多线程吧! 本文将对C#编程中的多线程机制进行探讨,通过一些实例解决对线程的控制,多线程间通讯等问题。为了省去创建GUI那些繁琐的步骤,更清晰地逼近线程的本质,下面所有的程序都是控制台程序,程序最后的Console.ReadLine()是为了使程序中途停下来,以便看清楚执行过程中的输出。 好了,废话少说,让我们来体验一下多线程的C#吧! 二.操纵一个线程 任何程序在执行时,至少有一个主线程,下面这段小程序可以给读者一个直观的印

用多线程同步方法解决生产者-消费者问题(操作系统课设)

用多线程同步方法解决生产者-消费者问题(操作系统课设)

题目 用多线程同步方法解决生产者-消费 者问题(Producer-Consume r Problem) 学院 物理学与电子信息工程学院 专业电子信息工程班级08电信本一班姓名 指导教师 2010 年12 月日

目录 目录 0 课程设计任务书 (1) 正文 (3) 1.设计目的与要求 (3) 1.1设计目的 (3) 1.2设计要求 (3) 2.设计思想及系统平台 (3) 2.1设计思想 (3) 2.2系统平台及使用语言 (3) 3.详细算法描述 (4) 4.源程序清单 (7) 5.运行结果与运行情况 (12) 6.调试过程 (16) 7.总结 (16)

课程设计任务书 题目: 用多线程同步方法解决生产者-消费者问题 (Producer-Consumer Problem) 初始条件: 1.操作系统:Linux 2.程序设计语言:C语言 3.有界缓冲区内设有20个存储单元,其初 值为0。放入/取出的数据项按增序设定为 1-20这20个整型数。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求) 1.技术要求: 1)为每个生产者/消费者产生一个线程,设计正确的同步算法 2)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的当前全部 内容、当前指针位置和生产者/消费者

线程的自定义标识符。 3)生产者和消费者各有两个以上。 4)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2.设计说明书内容要求: 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具 等。 3)数据结构与模块说明(功能与流程图) 4)给出用户名、源程序名、目标程序名和源程序及其运行结果。(要注明存储各个 程序及其运行结果的主机IP地址和目 录。) 5)运行结果与运行情况 (提示: (1)有界缓冲区可用数组实现。 (2)编译命令可用:cc -lpthread -o 目标文件名源文件名 (3)多线程编程方法参见附件。) 3. 调试报告: 1)调试记录 2)自我评析和总结

EJB中用JMS模拟多线程机制的设计和实现

收稿日期:2003-10-16 作者简介:高 燕(1976— ),女,四川人,硕士研究生,主要研究方向为计算机网络与信息系统。 E JB 中用JMS 模拟多线程机制的设计和实现 高 燕,李旭伟,文 震 (四川大学计算机学院,四川成都610064) 摘 要:多线程机制是提高系统执行效率的关键,但对于采用E JB 技术的服务器端,由于E JB 规范限制使用多线程机制,因此执行效率往往不那么令人满意。针对E JB 中不能使用线程这一缺陷,文中给出了在E JB 中如何用J MS 来模拟多线程机制并提供了一个具体的实现方案,将该方案用于网管系统中并发的获取各网络设备的MIB 信息以计算某一网络性能指标时取得了令人满意的成绩,大大缩短了系统运行的时间。从而可知在E JB 中采用J MS 技术来模拟多线程机制不仅在理论上可行,在实际应用中也是可行的。 关键词:多线程机制;企业JavaBean ;Java 消息服务 中图分类号:TP311.52 文献标识码:A 文章编号:1005-3751(2004)07-0040-03 Design and Implementation of Simulating Multithread Architecture with JMS in EJB G AO Yan ,L I Xu 2wei ,WEN Zhen (Department of Computer Science ,Sichuan University ,Chengdu 610064,China ) Abstract :It is a kind of key technology of multithread architecture to improve system executive efficiency ,but server uses E JB technology has not satisfying executive efficiency ,because E JB technology prohibits developers from using multithread architecture.This paper has explained how to simulate multithread architecture with J MS and presented a design according to the fact that multithread architecture can not be used in E JB ,when network management system uses the design to collect MIB information of network devices by which a network performance index can calculated ,the result is very good and executive time is shortened.So the design of simulating multithread architec 2ture with J MS in E JB is feasible not only in theory ,but also in application.K ey w ords :multithread architecture ;E JB ;J MS 随着J2EE 规范的成熟,E JB 技术已经在很多企业级的解决方案中得到了应用。针对软件执行效率这一客户关心的问题,一般采用的是多线程机制实现并发处理,但是对采用E JB 技术的应用服务器端这一问题却没能解决,因为E JB 规范为了消除与E JB 容器管理死锁、线程和并发问题的责任相冲突的可能性,限制使用任何方法启动、停止和管理线程。这就提出一个问题:在E JB 中如何实现多线程的机制?答案是采用J MS 技术。 1 相关技术介绍 1.1 EJB (E nterprise JavaB eans)简介 E JB 是实现了特定商业逻辑的JavaBean ,它部署在应 用服务器端的Container 中,可以灵活地加载、载出[1]。 J2EE 使用E JB Server 作为商业组件的部署环境,在E JB Server 中提供了分布式计算环境中组件需要的所有服务, 例如组件生命周期的管理、数据库连接的管理、分布式事务的支持、组件的命名服务等等,因此开发人员可以将精力更多的放在业务逻辑的实现上。 E JB 支持多种客户端的访问,HTTP 的客户端可以 通过Web Server 上的Java Servlet 或者J SP 发出请求,由 J SP 中嵌入的Java 代码调用运行在E JB Server 中的E JB 。 而其它的客户端,可以通过IIOP 直接访问运行在E JB Server 中的组件。E JB 主要由会话bean (Session Bean )和 实体bean (Entity Bean )、消息驱动bean (Message -Driven Bean )构成。会话bean 代表客户端代码需要调用的操作。 它是业务处理对象,实现了业务逻辑、业务规则、算法和工作流程。实体bean 用来代表底层的对象。最常用的是用实体bean 代表关系库中的资料。消息驱动bean 是在 E JB2.0规范中新增的一种Bean 类型。它是一种可以接 收J MS 消息的特殊的组件。由于MDB 不是RPC 组件,因此区别于其它类型的E JB ,MDB 不需要Remote 和 Home 接口。 1.2 JMS(Java Message Service)简介 (1)J MS 产生背景。 第14卷 第7期2004年7月 微 机 发 展Microcomputer Development Vol.14 No.7J uly 2004

多线程同步方法及比较

多线程同步方法及比较 多线程同步方法: 1.临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数 据访问。. 2.互斥量:为协调一起对一个共享资源的单独访问而设计的。. 3.信号量:为控制一个具备有限数量用户资源而设计。. 4.事件:用来通知线程有一些事件已发生,从而启动后继任务的开始。 临界区(Critical Section).. 确保在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。假如有多个线程试图同时访问临界区,那么在有一个线程进入后其他任何试图访问此临界区的线程将被挂起,并一直持续到进入临界区的线程离开。临界区在被释放后,其他线程能够继续抢占,并以此达到用原子方式操作共享资源的目的。 临界区包含两个操作原语: EnterCriticalSection()进入临界区 LeaveCriticalSection()离开临界区。 EnterCriticalSection()语句执行后代码将进入临界区以后无论发生什么,必须确保和之匹配的LeaveCriticalSection()都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快,但却只能用来同步本进程内的线程,而不可用来同步多个进程中的线程。 MFC为临界区提供有一个CCriticalSection类,使用该类进行线程同步处理是很简单的。只需在线程函数中用CCriticalSection类成员函数Lock()和UnLock()标定出被保护代码片段即可。Lock()后代码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。. ------------------------------------------------

相关文档
最新文档