//========================================================================
//TITLE:
// 如何写优雅的代码(4)——简单有效地玩转线程
//AUTHOR:
// norains
//DATE:
// Monday 23- November-2009
//Environment:
// WINDOWS CE 5.0
//========================================================================
线程的使用,说复杂吧,却又是只有那几个函数,无非就是通过CreateThread创建线程,然后再通过CloseHanle关闭句柄,大不了再加一个SetThreadPriority来设置优先级;说它简单吧,如何正常退出线程,如何有效地使用线程,却又往往让初学者头疼。
本文主题是如何简单却又有效地使用线程,但不涉及复杂的线程间数据交换。
首先,我们先来了解如何创建线程。很简单,调用CreateThread函数即可。该函数的原型如下:
- HANDLE CreateThread(
- LPSECURITY_ATTRIBUTES lpsa,
- DWORD cbStack,
- LPTHREAD_START_ROUTINE lpStartAddr,
- LPVOID lpvThreadParam,
- DWORD fdwCreate,
- LPDWORD lpIDThread
- )
lpsa形参好办,不用我们担心,只要直接设置为NULL;cbStack也容易,一般使用的话,我们也很少使用自定义的堆栈,所以这个也可以直接这只为NULL。lpStartAddr是最重要的一个,指向我们线程的处理函数。lpvThreadParam是传递给处理函数的形参,如果线程处理函数是封装于类中,那么这玩意可万万不能忽略。后面的fdwCreate和lpIDThread,如果没有特殊的用途,也可以一并设置为NULL。
所以,最简单的的线程创建函数的调用将可以如此:
- HANDLE hThrd = CreateThread(NULL,NULL,StartAddr,NULL,NULL,NULL);
如果后续不需要对该线程进行设置,比如更改优先级之类,那么创建完毕后,我们可以调用CloseHandle关闭句柄:
- CloseHandle(hThrd);
需要注意的是,这里的关闭句柄,并不意味着是关闭线程处理函数,而只是将句柄对象从系统中删除而已。简单但又不失严谨来说,对于系统,有一个列表,是用来记录创建的线程对象;当该对象不再使用时,我们必须将其关闭,以避免句柄泄漏。
接下来,我们再看看线程处理函数的原型:
- DWORD ThreadProc(
- LPVOID lpParameter
- );
没什么特别的,返回值为DWORD,形参只有一个,为lpParameter。这个lpParameter的数值,就是CreateThread的第四个形参。
我们简单地说说这形参是怎么传递的。
如果我们代码是这么创建线程的:
- DWORD dwValue = 123;
- CreateThread(NULL,NULL,ThreadProc,reinterpret_cast<VOID *>(dwValue),NULL,NULL);
那么我们的线程可以这么获取数值:
- DWORD ThreadProc(LPVOID pParam)
- {
- DWORD dwValue = reinterpret_cast<DWORD>(pParam);
- return 0;
- }
此时ThreadProc中的数值即为123。
似乎这形参并没有多大的作用,如果仅仅是为了传递一个DWORD类型的数值,我们完全可以采用全局变量的方式。那我们现在将话题往前推一点,看看在类中封装线程处理函数的情形。这时候,这个看似没多大用的形参,却是我们访问成员变量或函数的唯一桥梁。
在CreateThread的描述中,很清楚知道,我们不能将对象函数的地址作为参数传递,而只能传递类函数。通俗点来说,只有用了static修饰的函数才能作为形参。
如:
- class CBase
- {
- public:
- DWORD ThreadProc(LPVOID pParam);
- };
上面的的ThreadProc是无法作为函数形参的。但下面的这个,就能作为形参:
- class CBase
- {
- public:
- static DWORD ThreadProc(LPVOID pParam);
- };
虽然增加static修饰是可以作为形参传递,但我们不可避免会遇到一个问题,就是在ThreadProc中无法访问对象成员或对象函数。解决这个问题也是很简单,我们只需要将this指针作为参数传递给ThreadProc函数,然后再转换为对象指针,就能正常访问对象成员了。
创建线程时:
- HANDLE hThrd = CreateThread(NULL,NULL,ThreadProc,this,NULL,NULL);
- CloseHandle(hThrd);
然后是线程处理函数:
- DWORD CBase::ThreadProc(LPVOID pParam)
- {
- CBase *pObj = reinterpret_cast<CBase *>(pParam);
- if(pObj == NULL)
- {
- ASSERT(FALSE);
- return 0x10;
- }
- pObj->CheckSum(); //这里就可以直接调用对象函数
- }
在类中封装线程函数就是这么简单,关键只在于传递this指针而已。线程的基础差不多就说到这里,如果需要更详细的说明,可以查阅相关文档。只不过,到目前为止的介绍,对于接下来的说明已经足够了。
为了方便,接下来的讨论,我们都假设所有的操作都封装在类里。
之前我们有讨论过,CloseHandle并不是关闭线程,只是将线程的句柄从系统的列表中删除,那么,我们应该如何关闭线程呢?
普遍的,也是最受推荐的,就是让线程自己返回。
比如:
- DWORD CBase::ThreadProc(LPVOID pParam)
- {
- //TODO:Do thing.
- ...
- return 0;
- }
也许有人会问,API不是有TerminateThread函数么,调用该函数为什么不可以?当然可以,只不过非常不好。
加入我们有一个线程函数的代码如下:
- DWORD CBase::ThreadProc(LPVOID pParam)
- {
- LABEL1:
- if(IsTimeOut() == FALSE)
- {
- g_iFlag |= MUTEX_NOP;
- }
- LABEL2:
- if(IsCheckSystem() == FALSE)
- {
- g_iFlag |= MUTEX_CHECK;
- }
- LABEL3:
- if(IsBeautiful() == FALSE)
- {
- g_iFlag |= BEAUTIFULE;
- }
- return 0;
- }
如果在线程函数还在执行的时候,就调用TerminateThread,那么,最终g_iFlag会是什么数值?
如果执行到LABEL1,刚好调用TerminateThread,那么g_iFlag等于原值;如果是刚好执行到LABEL2,那么g_iFlag会设置MUTEX_CHECK位;如果再往下执行到LABEL3,那么就又和之前的完全不同。
更为重要的是,多线程,你在调用Terminate时,根本无法知道ThreadProc究竟执行到了哪一步。换句话说,这程序,每次实行,都可能会和上一次不一样,这难道不是一个灾难么?
所以,还是老老实实,线程该咋样就咋样,该自己退出就让它自生自灭吧!
线程的使用多种多样,本文无法一一列举,因此接下来的讨论,我们将范围缩小,局限于线程是不停地循环接收事件。
根据该要求我们很简单地罗列出相应的代码:
- void CBase::Create()
- {
- //创建事件
- m_hEventWait = CreateEvent(NULL,FALSE,FALSE,TEXT(“EVENT_WAIT”));
- //创建线程
- m_hThrd = CreateThread(NULL,NULL,ThreadProc,this,NULL,NULL);
- }
- DWORD CBase::ThreadProc(LPVOID pParam)
- {
- CBase *pObj = reinterpret_cast< CBase *>(pParam);
- if(pObj == NULL)
- {
- return 0x10;
- }
- while(TRUE)
- {
- //等待事件
- WaitForSingleObject(pObj->m_hEvnetWait, INFINITE);
- //TODO:在这里做接收到事件的动作
- }
- }
不过这段代码确实是有问题,因为我们无法让线程自己退出。那么,我们先采用一个最简单的方式,设置一个标志位,当该标志位为TRUE时,我们让线程跳出循环,然后直接线程返回。
线程部分代码更改如下:
- DWORD CBase::ThreadProc(LPVOID pParam)
- {
- CBase *pObj = reinterpret_cast< CBase *>(pParam);
- if(pObj == NULL)
- {
- return 0x10;
- }
- while(pObj->m_ExitProc != FALSE)
- {
- //每隔100MS就从函数返回,然后判断是否需要线程退出
- if(WaitForSingleObject(pObj->m_hEvnetWait, 100) != WAIT_TIMEOUT)
- {
- //TODO:在这里做接收到事件的动作
- }
- }
- }
但这样的修改,其实在效率上还是有点问题的。因为我们需要判断m_ExitProc的数值,所以我们对于WaitForSingleObject需要每隔一段时间就从等待中返回,然后再判断标志位。在这间隔性的返回当中,我们白白耗费了不少CPU时间。
为了避免这种无谓的损耗,我们应该改用WaitForMultipleObjects函数,同时等待两个事件。其中一个事件当然是我们之前所需要的,另外一个新的事件我们称其为唤醒事件,当接收到该事件时,我们就直接退出线程。
根据这个思想,那么我们代码又可以改装如下:
- void CBase::Create()
- {
- //创建唤醒事件
- m_hEvent[0] = CreateEvent(NULL,FALSE,FALSE,NULL);
- //创建等待事件
- m_hEvent[1] = CreateEvent(NULL,FALSE,FALSE,TEXT(“EVENT_WAIT”));
- //创建线程
- m_hThrd = CreateThread(NULL,NULL,ThreadProc,this,NULL,NULL);
- }
- DWORD CBase::ThreadProc(LPVOID pParam)
- {
- CBase *pObj = reinterpret_cast< CBase *>(pParam);
- if(pObj == NULL)
- {
- return 0x10;
- }
- while(TRUE)
- {
- //等待多个事件
- DWORD dwObj = WaitForMultipleObjects (pObj->m_hEvnetWait, INFINITE);
- if(dwObj == WAIT_OBJECT_0)
- {
- //跳出循环,退出函数
- break;
- }
- else
- {
- //TODO:在这里做接收到事件的动作
- }
- }
- }
嗯,这一下子,效率是提上去了。如果啥事情都没有呢,这线程就乖乖地在休息;如果有事情呢,它就会立马苏醒,然后再看看外面的世界。
只不过,工作正常了,并不代表优雅。简单地说,如果我们想知道当前这线程究竟是在运行,还是不在运行呢?
这个也非常简单,我们再给线程函数添加一个变量,当进入的时候设置TRUE,退出的时候设置FALSE。是不是也很简单呢?
代码如下:
- DWORD CBase::ThreadProc(LPVOID pParam)
- {
- CBase *pObj = reinterpret_cast< CBase *>(pParam);
- if(pObj == NULL)
- {
- return 0x10;
- }
- //在这里设置线程运行标识
- InterlockedExchange(reinterpret_cast<LONG *>(&m_bThrdRunning),TRUE);
- while(TRUE)
- {
- //等待多个事件
- DWORD dwObj = WaitForMultipleObjects (pObj->m_hEvnetWait, INFINITE);
- if(dwObj == WAIT_OBJECT_0)
- {
- //跳出循环,退出函数
- break;
- }
- else
- {
- //TODO:在这里做接收到事件的动作
- }
- }
- //在这里设置线程退出标识
- InterlockedExchange(reinterpret_cast<LONG *>(&m_bThrdRunning),FALSE);
- return 0;
- }
看到这里也许有人会觉得奇怪,因为对于m_bThrdRunning变量来说,也只有在线程里才会变更其数值,为什么还要祭出InterlockedExchange呢?对,没错,如果外部只需要读取其数值,而不用更改,那么只要简单地调用等号就好了。那为什么我们还要这么弄呢?主要是考虑到关闭线程的函数。
简单点来说,我们关闭线程的函数应该分为两种模式。一种模式为同步,另一种为异步。换句话来说,当其为异步模式时,我们只需要像线程发送个事件就好了;如果为同步模式,那么发送事件完毕后,我们还要判断退出标识。这时候,InterlockedExchange就派上用场了,我们可以采用它做一个自旋判断,直到其为FALSE,我们才退出关闭函数。
如上所言,则关闭函数如下:
- void CBase::Close(CloseFlag flag)
- {
- if(m_bProcRunning != FALSE)
- {
- SetEvent(m_hEvent[0]);
- if(flag == CLOSE_ASYNC)
- {
- //为异步模式,世界返回
- return;
- }
- //自旋等待,直到其线程退出
- while(InterlockedExchange(reinterpret_cast<LONG *>(& m_bThrdRunning),TRUE) == TRUE)
- {
- SetEvent(m_hEvent[0]);
- Sleep(100);
- }
- InterlockedExchange(reinterpret_cast<LONG *>(& m_bThrdRunning),FALSE);
- }
- //关闭线程句柄
- CloseHandle(m_hThrd);
- m_hThrd = NULL;
- }