线程

l        窗口置顶

::SetWindowPos(&wndTopMost, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | WS_EX_TOPMOST);

l        取消置顶

::SetWindowPos(GetSafeHwnd(), HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

 

l        写入配置文件。

::WritePrivateProfileString("Settings","AlwaysOnTop",m_bAlwaysOnTop? "1":"0",".\\Settings.ini");

 

l        读取配置文件

::GetPrivateProfileInt("Selections","m_bAddNew",0,".\\Settings.ini")

 

l        数据绑定

DDX_Check(pDX, IDC_CHECK1_ADDNEW, m_bAddNew);

 

//读写INI/ini文件************************************************* 

//写入值 字段名 变量名 值 带目录文件名 
WritePrivateProfileString("目录","path",cs, regpath); 
//写入结构体 字段名 变量名 值 大小 带目录文件名 
WritePrivateProfileStruct("字体","font",&LF,sizeof(LOGFONT),regpath);//结构体 
//读入字符 字段名 变量名 默认值 字符缓冲区 长度 带目录文件名 
GetPrivateProfileString("目录","path","", buffer.GetBuffer(260),260,regpath); 
//读入整数值 字段名 变量名 默认值 带目录文件名 
GetPrivateProfileInt("colors","red",255, regpath); 
//读入结构体 字段名 变量名 值 大小 带目录文件名 
GetPrivateProfileStruct("字体","font",&LF,sizeof(LOGFONT),regpath); 

线程

进程是资源分配的基本单位。所有与该进程有关的资源，都被记录在进程控制块PCB中。以表示该进程拥有这些资源或正在使用它们。　　

另外，进程也是抢占处理机的调度单位，它拥有一个完整的虚拟地址空间。 　　

与进程相对应，线程与资源分配无关，它属于某一个进程，并与进程内的其他线程一起共享进程的资源。　　

当进程发生调度时，不同的进程拥有不同的虚拟地址空间，而同一进程内的不同线程共享同一地址空间。 　　

线程只由相关堆栈（系统栈或用户栈）寄存器和线程控制表TCB组成。寄存器可被用来存储线程内的局部变量，但不能存储其他线程的相关变量。　　

发生进程切换与发生线程切换时相比较，进程切换时涉及到有关资源指针的保存以及地址空间的变化等问题；线程切换时，由于同进程内的线程共享资源和地址空间，将不涉及资源信息的保存和地址变化问题，从而减少了操作系统的开销时间。而且，进程的调度与切换都是由操作系统内核完成，而线程则既可由操作系统内 核完成，也可由用户程序进行。

因为进程内的线程分享相同的资源，所以需要在系统级别上设置控制机制来保证数据的完整性。当一个线程修改了某个变量，而另一个线程试图读取它时，或者两个线程同时修改同一变量，就会影响到数据的完整性，为防止这个问题，操作系统提供了一种相互排斥对象，简写为mutex。在多线程程序中，mutex是通过编程来实现的，可防止多个线程在同一时间访问同一资源。    当一个线程需要访问某一资源时，它必须先请求一个mutex，一旦线程得到一个mutex，其他想获取同一mutex的线程被阻塞，并处于低CPU占用的等待状态；一旦这个线程完成了数据访问，它会释放对应的mutex，这就允许其他线程获取以访问相关的数据。

线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

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

每个线程中都应具有一个用于控制线程运行的线程控制块TCB，用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。

1.轻型实体 　　

线程中的实体基本上不拥有系统资源，只是有一点必不可少的、能保证独立运行的资源，比如，在每个线程中都应具有一个用于控制线程运行的线程控制块TCB，用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。 　　

2.独立调度和分派的基本单位。 　　

在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。由于线程很“轻”，故线程的切换非常迅速且开销小。 　　

3.可并发执行。 　　

在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行。 　

4.共享进程资源。 　　

在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的地址空间（进程的地址空间），这意味着，线程可以访问该地址空间的每一个虚地址；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。

　　

线程与进程的区别可以归纳为以下几点： 　　

l         地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。　　

l         通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。 　　

l         调度和切换：线程上下文切换比进程上下文切换要快得多。　　

l         在多线程OS中，进程不是一个可执行的实体。

 

线程的生命状态与周期

1.新建 2.就绪 3.运行 4.阻塞 5.死亡

线程有两个基本类型：

　　用户级线程：管理过程全部由用户程序完成，操作系统内核心只对进程进行管理。

系统级线程（核心级线程）：由操作系统内核进行管理。操作系统内核给应用程序提供相应的系统调用和应用程序接口API，以使用户程序可以创建、执行、撤消线程。

 

 

函数	操作系统	描述	使用的类
CreateThread	Windows	创建一个Windows线程	CThread
WaitForSingleObject	Windows	等待一个对象有信号	CThread, CMutex, CEvent
CreateMutex	Windows	创建一个命名或未命名的mutex	CMutex
CloseHandle	Windows	关闭某一Windows句柄以释放资源	CMutex, CEvent, CThread
ReleaseMutex	Windows	释放某一之前获取，并由WaitForSingleObject锁定的 mutex	CMutex CEvent
CreateEvent	Windows	创建一个Windows事件对象	CEvent
SetEvent	Windows	设置某一Windows事件对象为有信号状态	CEvent

 

 

CMutex类的函数

函数	描述
void CMutex()	构造函数
void Lock()	锁定mutex对象或当它阻塞时等待
void Unlock()	解锁之前阻塞的mutex

 

2、DWORD SuspendThread(HANDLE hThread);

该函数用于挂起指定的线程，如果函数执行成功，则线程的执行被终止。 3、DWORD

3、ResumeThread(HANDLE hThread);

该函数用于结束线程的挂起状态，执行线程。

4、VOID ExitThread(DWORD dwExitCode);

该函数用于线程终结自身的执行，主要在线程的执行函数中被调用。其中参数dwExitCode用来设置线程的退出码。

5、BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);

　　一般情况下，线程运行结束之后，线程函数正常返回，但是应用程序可以调用TerminateThread强行终止某一线程的执行。各参数含义如下：

hThread：将被终结的线程的句柄；

dwExitCode：用于指定线程的退出码。

　　使用TerminateThread()终止某个线程的执行是不安全的，可能会引起系统不稳定；虽然该函数立即终止线程的执行，但并不释放线程所占用的资源。因此，一般不建议使用该函数。

6、BOOL PostThreadMessage(DWORD idThread,

            UINT Msg,

            WPARAM wParam,

            LPARAM lParam);

 

l         该函数将一条消息放入到指定线程的消息队列中，并且不等到消息被该线程处理时便返回。

l         idThread：将接收消息的线程的ID；

l         Msg：指定用来发送的消息；

l         wParam：同消息有关的字参数；

l         lParam：同消息有关的长参数；

l         调用该函数时，如果即将接收消息的线程没有创建消息循环，则该函数执行失败。

volatile 修饰符的作用是告诉编译器无需对该变量作任何的优化，即无需将它放到一个寄存器中，并且该值可被外部改变。对于多线程引用的全局变量来说，volatile 是一个非常重要的修饰符。

 

终止线程

WaitForSingleObject函数，其函数原型为：DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);

 

hHandle为要监视的对象（一般为同步对象，也可以是线程）的句柄；

dwMilliseconds为hHandle对象所设置的超时值，单位为毫秒；

　　当在某一线程中调用该函数时，线程暂时挂起，系统监视hHandle所指向的对象的状态。如果在挂起的dwMilliseconds毫秒内，线程所等待的对象变为有信号状态，则该函数立即返回；如果超时时间已经到达dwMilliseconds毫秒，但hHandle所指向的对象还没有变成有信号状态，函数照样返回。参数dwMilliseconds有两个具有特殊意义的值：0和INFINITE。若为0，则该函数立即返回；若为INFINITE，则线程一直被挂起，直到hHandle所指向的对象变为有信号状态时为止。

　　本例程调用该函数的作用是按下IDC_START按钮后，一直等到线程返回，再恢复IDC_START按钮正常状态。编译运行该例程并细心体会。

::TerminateThread(m_hThread, 0 );

m_hThread = NULL;

 

HANDLE m_hThread;//线程

DWORD m_hThreadId;  //线程ID

  static DWORD WINAPI ThreadProc( LPVOID lParam ) //线程函数，非类成员

{

    CString str;

    str.Format(L"%d",AfxGetApp()->m_nThreadID);

//AfxGetApp()获取当前运行的程序对象指针CheheDlg*

    ((CheheDlg*)lParam)->SetDlgItemText(IDC_EDIT1,str);//转换对象指针

    return 1;

}

//如果未传递当前运行的句柄。

    CListBox *list;

    list=(CListBox*)AfxGetApp()->GetMainWnd()->GetDlgItem(IDC_LIST1);

    list->AddString(str);

AfxGetApp()获取了该应用程序的实例句柄

GetMainWnd()获取了该应用程序的主窗口

 

    m_hThread=::CreateThread(NULL,0,ThreadProc,this,0,&m_hThreadId);//this当前对象指针

 

线程的创建

使用CreateThread函数创建线程，CreateThread的原型如下：

HANDLE CreateThread(

LPSECURITY_ATTRIBUTES lpThreadAttributes,

DWORD dwStackSize,

LPTHREAD_START_ROUTINE lpStartAddress,

LPVOID lpParameter,

DWORD dwCreationFlags, // creation flags

LPDWORD lpThreadId

);

其中：

l         lpThreadAttributes表示创建线程的安全属性，NT下有用。

l         dwStackSize指定线程栈的尺寸，如果为0则与进程主线程栈相同。

l         lpStartAddress指定线程开始运行的地址。

l         lpParameter表示传递给线程的32位的参数。

l         dwCreateFlages表示是否创建后挂起线程(取值CREATE_SUSPENDED)，挂起后调用ResumeThread继续执行。

l         lpThreadId用来存放返回的线程ID。

 

    h=CreateThread(NULL,NULL,ThreadProc,this,CREATE_SUSPENDED,NULL);//创建后挂起线程

ResumeThread(h);//恢复线程

SuspendThread(h);//挂起线程

 

static DWORD WINAPI ThreadProc( LPVOID lParam )

{

    CString str;

    CTime c;

    while(1)

    {

        c=CTime::GetCurrentTime();

        str=c.Format("%H:%M:%S");

    ((CheheDlg*)lParam)->SetDlgItemText(IDC_EDIT1,str);

    }

        return 0;

}

  

//获取当前线程的优先级

        DWORD dw= GetThreadPriority(GetCurrentThread());

        str.Format(L"%x",dw);

 

//设置线程优先级：1：线程句柄  2：优先级THREAD_PRIORITY_NORMAL    0

BOOL WINAPI SetThreadPriority(

  __in          HANDLE hThread,

  __in          int nPriority

);

 

线程的终止

以下情况终止一个线程：

l         调用了ExitThread函数；

l         线程函数返回：主线程返回导致ExitProcess被调用，其他线程返回导致ExitThread被调用；

l         调用ExitProcess导致进程的所有线程终止；

l         调用TerminateThread终止一个线程；

l         调用TerminateProcess终止一个进程时，导致其所有线程的终止。

l         当用TerminateProcess或者TerminateThread终止进程或线程时，DLL的入口函数DllMain不会被执行（如果有DLL的话）。

 

线程同步

同步可以保证在一个时间内只有一个线程对某个资源（如操作系统资源等共享资源）有控制权。共享资源包括全局变量、公共数据成员或者句柄等。同步还可以使得有关联交互作用的代码按一定的顺序执行。

同步对象有：Critical_section（关键段），Event（事件），Mutex（互斥对象），Semaphores（信号量）。

 

在Win32 API的基础之上，MFC提供了处理线程的类和函数。处理线程的类是CWinThread，函数是AfxBeginThread、AfxEndThread等。

CWinThread是MFC线程类，它的成员变量m_hThread和m_hThreadID是对应的Win32线程句柄和线程ID。

MFC明确区分两种线程：用户界面线程(User interface thread)和工作者线程(Worker thread)。用户界面线程一般用于处理用户输入并对用户产生的事件和消息作出应答。工作者线程用于完成不要求用户输入的任务，如耗时计算。

Win32 API并不区分线程类型，它只需要知道线程的开始地址以便它开始执行线程。MFC为用户界面线程特别地提供消息泵来处理用户界面的事件。CWinApp对象是用户界面线程对象的一个例子，CWinApp从类CWinThread派生并处理用户产生的事件和消息。

 

　为了防止用户定义的消息ID与系统的消息ID冲突，MS（Microsoft）定义了一个宏WM_USER，小于WM_USER的ID被系统使用，大于WM_USER的ID被用户使用。

 

PostMessage是Windows API(应用程序接口) 中的一个常用函数，用于将一条消息放入到消息队列中。该函数将一个消息放入（寄送）到与指定窗口创建的线程相联系消息队列里，不等待线程处理消息就返回，是异步消息模式。消息队列里的消息通过调用GetMessage和PeekMessage取得。函数原型：B00L PostMessage（HWNDhWnd，UINTMsg，WPARAMwParam，LPARAMlParam）； 　　

参数说明：　　

hWnd：其窗口程序接收消息的窗口的句柄。可取有特定含义的两个值： 　　

HWND_BROADCAST：消息被寄送到系统的所有顶层窗口，包括无效或不可见的非自身拥有窗口、 被覆盖的窗口和弹出式窗口。消息不被寄送到子窗口　　

NULL：此函数的操作和调用参数dwThread设置为当前线程的标识符PostThreadMessage函数一样 　　

Msg：指定被寄送的消息。 　　

wParam：指定附加的消息特定的信息。 　　

IParam：指定附加的消息特定的信息。 　　

返回值：如果函数调用成功，返回非零值：如果函数调用失败，返回值是零。若想获得更多的错误信息，请调用GetLastError函数。

 

使隶属于同一进程的各线程协调一致地工作称为线程同步

 

使用 CCriticalSection 类

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

 

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才会继续执行。

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

 

CEvent eventWriteD;

线程WriteD执行到 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);处等待，直到事件eventWriteD为有信号该线程才往下执行，因为eventWriteD对象是自动事件，则当WaitForSingleObject()返回时，系统自动把eventWriteD对象重置为无信号状态

    CWinThread *pWriteD=AfxBeginThread(WriteD,

        &m_ctrlD,

        THREAD_PRIORITY_NORMAL,

        0,

        CREATE_SUSPENDED);

    pWriteD->ResumeThread();

 

C、使用CMutex 类

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

 

D、使用CSemaphore 类  afxmt.h

　　当需要一个计数器来限制可以使用某个线程的数目时，可以使用“信号量”对象。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 semaphoreWrite(2,2); //资源最多访问线程2个，当前可访问线程数2个

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;

}

在信号量对象有信号的状态下，线程执行到WaitForSingleObject语句处继续执行，同时可用线程数减1；若线程执行到WaitForSingleObject语句时信号量对象无信号，线程就在这里等待，直到信号量对象有信号线程才往下执行。

 

#include<iostream>

#include <Windows.h>

#include <cstdio>

using namespace std;

int nCount=50;   

DWORD ThreadID1;

DWORD ThreadID2;

DWORD ThreadID3;

HANDLE hMutex;

DWORD WINAPI TProc1(LPVOID lParam)

{

    while(nCount>0)

    {

       Sleep(1);

       WaitForSingleObject(hMutex,INFINITE);

       printf("nCount=%d----线程\n",nCount);

       nCount--;

       ReleaseMutex(hMutex);

      

    }

    return 1;

}

DWORD WINAPI TProc2(LPVOID lParam)

{

    while(nCount>0)

    {      Sleep(1);

       WaitForSingleObject(hMutex,INFINITE);

       printf("nCount=%d----线程\n",nCount);

       nCount--;

       ReleaseMutex(hMutex);

    }

    return 1;

}

 

 

int main(void)

{

    hMutex=CreateMutex(NULL,NULL,NULL);

    HANDLE h1=CreateThread(NULL,NULL,TProc1,NULL,NULL,&ThreadID1);

    HANDLE h2=CreateThread(NULL,NULL,TProc2,NULL,NULL,&ThreadID2);

    Sleep(5000);

    return 0;

}