- 浏览: 951618 次
文章分类
最新评论
-
l67721363:
感谢分享,要是有各个函数性能比较就好了。
SQL优化 数据库优化 -
hanmiao:
此图片来自QQ空间,未经允许不可引用。
Hacking QQ空间
Windows线程同步
转自:http://buaadallas.blog.51cto.com/399160/128889
虽然多线程能给我们带来好处,但是也有不少问题需要解决。例如,对于像磁盘驱动器这样独占性系统资源,由于线程可以执行进程的任何代码段,且线程的运行是由系统调度自动完成的,具有一定的不确定性,因此就有可能出现两个线程同时对磁盘驱动器进行操作,从而出现操作错误;又例如,对于银行系统的计算机来说,可能使用一个线程来更新其用户数据库,而用另外一个线程来读取数据库以响应储户的需要,极有可能读数据库的线程读取的是未完全更新的数据库,因为可能在读的时候只有一部分数据被更新过。
使隶属于同一进程的各线程协调一致地工作称为线程的同步。MFC提供了多种同步对象,下面我们只介绍最常用的四种:
- 临界区(CCriticalSection)
- 事件(CEvent)
- 互斥量(CMutex)
- 信号量(CSemaphore)
CCriticalSection类的用法非常简单,步骤如下:
- 定义CCriticalSection类的一个全局对象(以使各个线程均能访问),如CCriticalSection critical_section;
- 在访问需要保护的资源或代码之前,调用CCriticalSection类的成员Lock()获得临界区对象:
critical_section.Lock();
在线程中调用该函数来使线程获得它所请求的临界区。如果此时没有其它线程占有临界区对象,则调用Lock()的线程获得临界区;否则,线程将被挂起,并放入到一个系统队列中等待,直到当前拥有临界区的线程释放了临界区时为止。 - 访问临界区完毕后,使用CCriticalSection的成员函数Unlock()来释放临界区:
critical_section.Unlock();
再通俗一点讲,就是线程A执行到critical_section.Lock();语句时,如果其它线程(B)正在执行 critical_section.Lock();语句后且critical_section. Unlock();语句前的语句时,线程A就会等待,直到线程B执行完critical_section. Unlock();语句,线程A才会继续执行。
例程8 MultiThread8
- 建立一个基于对话框的工程MultiThread8,在对话框IDD_MULTITHREAD8_DIALOG中加入两个按钮和两个编辑框控件,两个按钮的ID分别为IDC_WRITEW和IDC_WRITED,标题分别为“写‘W’”和“写‘D’”;两个编辑框的ID分别为IDC_W和IDC_D,属性都选中Read-only;
- 在MultiThread8Dlg.h文件中声明两个线程函数:
UINT WriteW(LPVOID pParam);
UINT WriteD(LPVOID pParam); - 使用ClassWizard分别给IDC_W和IDC_D添加CEdit类变量m_ctrlW和m_ctrlD;
- 在MultiThread8Dlg.cpp文件中添加如下内容:
为了文件中能够正确使用同步类,在文件开头添加:#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;
} - 分别双击按钮IDC_WRITEW和IDC_WRITED,添加其响应函数:
void CMultiThread8Dlg::OnWritew()
由于代码较简单,不再详述。编译、运行该例程,您可以连续点击两个按钮,观察体会临界类的作用。
{
CWinThread *pWriteW=AfxBeginThread(WriteW,
&m_ctrlW,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED);
pWriteW->ResumeThread();
}
void CMultiThread8Dlg::OnWrited()
{
CWinThread *pWriteD=AfxBeginThread(WriteD,
&m_ctrlD,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED);
pWriteD->ResumeThread();
}
在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 类的理解确实有些难度,但您只要通过仔细玩味下面例程,多看几遍就可理解。
- 建立一个基于对话框的工程MultiThread9,在对话框IDD_MULTITHREAD9_DIALOG中加入一个按钮和两个编辑框控件,按钮的 ID为IDC_WRITEW,标题为“写‘W’”;两个编辑框的ID分别为IDC_W和IDC_D,属性都选中Read-only;
- 在MultiThread9Dlg.h文件中声明两个线程函数:
UINT WriteW(LPVOID pParam);
UINT WriteD(LPVOID pParam); - 使用ClassWizard分别给IDC_W和IDC_D添加CEdit类变量m_ctrlW和m_ctrlD;
- 在MultiThread9Dlg.cpp文件中添加如下内容:
为了文件中能够正确使用同步类,在文件开头添加
#include "afxmt.h"
定义事件对象和一个字符数组,为了能够在不同线程间使用,定义为全局变量。CEvent eventWriteD;
添加线程函数:
char g_Array[10];UINT WriteW(LPVOID pParam)
仔细分析这两个线程函数, 您就会正确理解CEvent 类。线程WriteD执行到 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);处等待,直到事件eventWriteD为有信号该线程才往下执行,因为eventWriteD对象是自动事件,则当WaitForSingleObject()返回时,系统自动把 eventWriteD对象重置为无信号状态。
{
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;
} - 双击按钮IDC_WRITEW,添加其响应函数:
void CMultiThread9Dlg::OnWritew()
编译并运行程序,单击“写‘W’”按钮,体会事件对象的作用。
{
CWinThread *pWriteW=AfxBeginThread(WriteW,
&m_ctrlW,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED);
pWriteW->ResumeThread();
CWinThread *pWriteD=AfxBeginThread(WriteD,
&m_ctrlD,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED);
pWriteD->ResumeThread();
}
CSemaphore 类的构造函数原型及参数说明如下:
CSemaphore (LONG lInitialCount=1,
LONG lMaxCount=1,
LPCTSTR pstrName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);
- lInitialCount:信号量对象的初始计数值,即可访问线程数目的初始值;
- lMaxCount:信号量对象计数值的最大值,该参数决定了同一时刻可访问由信号量保护的资源的线程最大数目;
- 后两个参数在同一进程中使用一般为NULL,不作过多讨论;
- 建立一个基于对话框的工程MultiThread10,在对话框IDD_MULTITHREAD10_DIALOG中加入一个按钮和三个编辑框控件,按钮的ID为IDC_START,标题为“同时写‘A’、‘B’、‘C’”;三个编辑框的ID分别为IDC_A、IDC_B和IDC_C,属性都选中 Read-only;
- 在MultiThread10Dlg.h文件中声明两个线程函数:
UINT WriteA(LPVOID pParam);
UINT WriteB(LPVOID pParam);
UINT WriteC(LPVOID pParam); - 使用ClassWizard分别给IDC_A、IDC_B和IDC_C添加CEdit类变量m_ctrlA、m_ctrlB和m_ctrlC;
- 在MultiThread10Dlg.cpp文件中添加如下内容:
为了文件中能够正确使用同步类,在文件开头添加:
#include "afxmt.h"
定义信号量对象和一个字符数组,为了能够在不同线程间使用,定义为全局变量:CSemaphore semaphoreWrite(2,2); //资源最多访问线程2个,当前可访问线程数2个
char g_Array[10];添加三个线程函数:UINT WriteA(LPVOID pParam)
这三个线程函数不再多说。在信号量对象有信号的状态下,线程执行到WaitForSingleObject语句处继续执行,同时可用线程数减1;若线程执行到WaitForSingleObject语句时信号量对象无信号,线程就在这里等待,直到信号量对象有信号线程才往下执行。
{
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;
} - 双击按钮IDC_START,添加其响应函数:
void CMultiThread10Dlg::OnStart()
{
CWinThread *pWriteA=AfxBeginThread(WriteA,
&m_ctrlA,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED);
pWriteA->ResumeThread();
CWinThread *pWriteB=AfxBeginThread(WriteB,
&m_ctrlB,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED);
pWriteB->ResumeThread();
CWinThread *pWriteC=AfxBeginThread(WriteC,
&m_ctrlC,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED);
pWriteC->ResumeThread();
}
//////////////////////////////////////////////////////////////
http://blog.csdn.net/wqf363/archive/2008/04/25/2328555.aspx
线程之间的同步使用一些核心对象:如thread, process, evnet, mutex, semaphore. 在线程之间使用等待函数如WaitForSingleObjects,
WaitForMultipleObjects. 等待函数使用核心对象的handle作为参数,如果handle被激发,则执行下一步。
handle被激发的条件: (handle是一段内存指针,为了掩藏内部实现而作的一个类型转化指针)
激发:---我的理解是资源未被战胜。未激发: ---资源正在被占用。
eg: 1)thread, process被终止,则激发。
2)event: 要通过它的API来手动激发,是最灵活的激发方式,可被所有线程使用。
3)mutex: 没被任何线程所拥有,则激发。
1)临界区: CRITICAL_SECTION 适用范围: 单一进程的各线程之间用来排它性占有特性: 局部性对象; 快速而有效.
无法监测是否被线程放弃函数: EnterCriticalSection LeaveCriticalSection
2)Mutex: 适用范围: 不同线程之间用来排它性占有特性: 核心对象, 可以使用wait进行等待,
只能被拥有线程所释放函数:CreateMutex ReleaseMutex
3)semaphore: 信号量 适用范围: 用来限制资源占用特性: 核心对象,没有拥有者,
任何线程都可释放函数:CreateSemaphore OpenSemaphore ReleaseSemaphore
4)Event: 适用范围: 同来控制对象信号的接收,常与信号系统结合起来特性:
核心对象函数: CreateEvent OpenEvent PulseEvent SetEvent ResetEvent
5)Interlocked 简单的原子操作,如写文件中对文件中字节范围的锁定_locking
NOTE: 线程同步中很重要的可归纳为锁系统lock和信号系统signal lock
包括:CRITICAL_SECTION, Mutex, wait function: WaitForMultipleObjects WaitForSingleObject Sleep
6)completion port 适用范围: 网络异步接收,包括文件读写特性:由OS来控制读写, 是windows平台最有效的同步机制,
相当于linux的AIO或者非阻塞socket+epoll 函数: CreateIoCompletionPort GetQueuedCompletionStatus
示例1: event //事件机制: 设置一个全局event对象,这个只能等待最多64个对象,而且要用WaitForMultipleObjects来监视
线程handle数组. 不如完全端口completion port HANDLE ghWriteEvent; HANDLE ghThreads[THREADCOUNT];
(1)创建个手动事件,一开始不接受任何信号no signel //ResetEvent: 用来信号重置,同CreateEvent or
OpenEvent ghWriteEvent = CreateEvent( NULL, // default security attributesTRUE,// manual-reset event
FALSE,// initial state is nonsignaledTEXT("WriteEvent") // object name);
(2)产生一堆线程,设置事件响应信号signal, if (! SetEvent(ghWriteEvent) ) {
printf("SetEvent failed (%d)/n", GetLastError()); return; } //
(3)设置线程等待事件,所有线程都接到这个事件,,这里对线程进行了同步,只有所有线程都执行了,才执行下一步
dwWaitResult = WaitForMultipleObjects(THREADCOUNT, // number of handles in array
ghThreads,// array of thread handles TRUE, // wait until all are signaled INFINITE);
{ //(3.1)其中每个线程函数都在等待事件对象,这里也对线程进行了同步,只有得到signal的线程才执行下一步
dwWaitResult = WaitForSingleObject( ghWriteEvent, // event handleINFINITE); // indefinite wait}
(4)关闭了这个全局事件 == CloseHandle(ghWriteEvent) CloseEvents();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
http://thatax.blog.163.com/blog/static/20892680200882532745176/
多线程使用总结基础:
1)最好使用C++ runtime的函数创建线程,即调用_beginthreadex创建线程。CreateThread()函数并不会执行C运行时数据块的变量的每线程初始化,
因此在任何使用C运行时库的应用中,不能使用CrateThread()函数。
2)最好不要显示的调用ExitThread()或TerminateThread(),因为调用这些不进行清理工作。
3)SuspendThread()挂起线程时,要考虑该线程是否拥有Mutex或Semaphore,如果拥有的话可能会导致死锁。
4)信号量Semaphore,是一个可以限制对指定的临界段进行访问的线程的数目的数据结构。
5)互斥量Mutex和关键代码段CriticalSection,他们的作用是相同的,都是用来保证某时刻只有一个线程能够访问全局或静态的资源。
区别是:Mutex是内核对象,可以设置等待超时时间,可以在不同的进程的线程中使用,但是所消耗的时间也比较多。CriticalSection与Mutex相反。
6)互锁函数,可以用来实现原子操作。对于一些简单的问题,比如说int变量的自加,交换。。。
7)线程局部存储(TLS),可以为全局或静态变量对不同的线程有不同的拷贝。
高级:
8)线程池,可以实现在程序中根据需要动态的创建线程,比如在server端,根据访问的用户的多少来创建线程的多少。
在windows2000以后增加了创建线程池的API,比如 QueueUserWorkItem()。
9)线程的优先级,用来保证重要的事情先被完成。不能使用线程的优先级来解决线程的同步问题。
10) 处理器亲和,就是将线程固定在某cpu上执行,这样在某些情况下有助于提高性能,例如我们有双核的且支持超线程技术的cpu,我们有4个线程,
有2个是IO操作,有2个是大量的计算,对于上面的问题,我们就可以使用处理器亲和,使用API设置,来达到cpu使用的均和,更好的提高性能。
11) 纤程,用户级的线程机制,比线程小的单位,开发人员负责管理纤程的调度,同时负责确定纤程何时在线程时间片上下文中运行,
一般不会带来性能的提高,主要的目的是为开发人员调度多个不需要并行执行的任务提供一个便捷的机制。
12) 是否需要使用多线程,最总是需要测试来决定的,而且对于不同的CPU结果也不相同。避免使用过多的线程而带来性能下降。
其他多线程技术:13) MFC多线程,多Windows多线程API的封装。
14) Boost多线程。
15) POSIX,Pthreads,是一个可以移植的多线程库。一般是Linux和Unix是商用较多。
16) Intel Open MP+,是一种可移植的多线程解决方案。(www.openmp.org)。
多线程调试:
17) 支持多线程的Log。
18) VS2005中,可以查看Thread窗口,挂起或恢复线程,切换当前的线程和检查线程状态。或是使用TracePoint来输出消息到output。
19)使用SetThreadName()来对线程命名,使用线程信息block (http://www.codeproject.com/threads/xtib.asp)。
20) 使用Intel多线程线程检测器,Intel调试器。。。
相关推荐
操作系统实验报告—Windows线程同步机制.doc
操作系统实验报告—Windows线程同步机制.pdf
windows 下的线程同步 ,请的很详细。
Windows多线程间同步事件的控制方法!!!
windows下的一些同步方法,volatile、Interlocke函数、CRITICAL_SECTION、SRWLOCK、Mutex。
windows多线程的同步和互斥
小实验三:根据同步机制的Peterson软件解决方案尝试自己编程实现线程同步机制和用于上述线程并发问题的解决,并基于程序运行时间长短将其与基于Windows互斥信号量的线程同步机制的效率展开比较。 实验要求:线程主体...
在windows的环境下,创建一个控制台进程,此进程创建两个并发线程,一个是读线程,另一个是写线程。这两个线程共享一个数组A,写线程对数组分别进行10次写操作,每次写操作对A的每个元素赋一个相同的值;读线程对数组...
windows系统的多线程同步实验报告和cpp文件
线程同步的几种方式的c++方法,Mutex,Event,Semaphore等
在掌握基于消息的windows程序结构和多线程程序设计方法的基础上,设计一个多线程同步的程序。使学生能够从程序设计的角度了解多线程程序设计的方法和在windows系统下多线程同步互斥的机制。 2、实验内容 理解Windows...
操作系统实验 线程的同步 深入理解线程与进程的概念,在Windows环境下何时使用进程,何时使用线程?
C/C++ windows 线程同步+互斥 学习理解 源代码
实验4Windows线程互斥同步.pdf
在windows平台上建立的c++多线程demo,利用信号量实现线程同步功能。
线程和内核对象的同步,详细的讲解了4种内核对象的同步过程,以及他们之间的差别
thread:未使用windows互斥信号量程序 thread2:使用windows互斥信号量程序 thread3:使用同步机制的peterson软件解决方案
示例代码展示了如果在windows实现多线程的同步,如何在多核CPU上开辟多个线程同时运行。
Windows的多线程同步实验报告