c++builder 多线程-创建 退出 及获取线程返回码

1. WIN32 API线程的创建

在程序中调用CreateThread函数可以创建一个线程：

 HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES lpThreadAttributes,
  DWORD dwStackSize,
  LPTHREAD_START_ROUTINE lpStartAddress,
  LPVOID lpParameter,
 DWORD dwCreationFlags,
 LPDWORD lpThreadId);

每个参数的含义为：

LPSECURITY_ATTRIBUTES lpThreadAttributes   一般设为NULL。

     该参数是指向一个SECURITY_ATTRIBUTES结构的指针。如果要赋予该线程内核对象缺省的安全属性，可以传递一个NULL。如果希望所有的子进程能够继承该线程对象的句柄，须设定一个SECURITY_ATTRIBUTES结构，它的bInheritHandle成员应初始化为TRUE。

DWORD dwStackSize  一般设为0

     该参数指定线程栈的大小。每个线程都拥有它自己的堆栈。如果dwStakSize为0，系统默认保留的栈的空间为1MB。

LPTHREAD_START_ROUTINE lpStartAddress  入口函数

    该参数用于指定新建线程的入口函数的地址。可以创建多个线程，使用相同的入口函数地址。该入口函数的原型为：

   DWORD WINAPI ThreadFunc(LPVOID lpParameter);

   名字可以改变，返回类型和参数相同就可以。

DWORD dwCreationFlags   一般为0

该参数控制创建线程的标志，它可以是0或者CREATE_SUSPENDED。如果是0，则新建立的线程在创建完毕后被系统调度程序调度(可能被执行，也可能不被执行，这取决于系统中其他线程的优先级情况)。如果该值为CREATE_SUSPENDED,系统在创建完新线程后，新线程被系统挂起，直到有其他线程执行了带该新线程句柄的ResumeThread()函数后，新线程才被激活。

LPDWORD lpThreadId  一般为NULL

该参数指定新线程的ID。在Windows95中，该参数不能为NULL，否则会引起错误，在Windows 2000中该参数可以为NULL。

例1：
创建线程,并传递参数：

 DWORD WINAPI SubThread(LPVOID lpParam)
 {
     TRACE("SubThread,lpParam is:%d\n",lpParam);
     return 0;
 }

 void MainThread()
 {
     HANDLE hThread=CreateThread(NULL,0,SubThread,(LPVOID)123,0,NULL);
     Sleep(1000);
     CloseHandle(hThread);
 }

例2：
创建挂起的新线程，老线程执行一些工作后，再激活新创建的线程。

 DWORD WINAPI SubThread(LPVOID lpParam)
 {
     TRACE("SubThread,lpParam is:%d\n",lpParam);
     return 0;
 }
 
 void MainThread()
 {
     HANDLE hThread=CreateThread(NULL,0,SubThread,(LPVOID)123,CREATE_SUSPENDED,NULL);
     TRACE("SubThread is created\n");
     ResumeThread(hThread);
     Sleep(1000);
     CloseHandle(hThread);
 }

2. 线程的终止
可以使用下面方法来终止线程：
线程函数的返回；
 (1)通过调用ExitThread函数，线程 将自己撤销；
 (2)同一个进程或者另一个进程中的线程调用 TerminateThread函数终止另外一个线程的运行；
 (3)包含线程的进程终止运行(主线程退出)。

1、 线程函数返回。

这是确保线程的所有资源被正确地清除的 唯一办法。当线程函数返回时，如下情况将会发生：
 在线程函数中创建的所有C++对象将通过它们的析构函数正确地撤销；
操作系统将正确地释放线程的堆栈使用的内存；
系统将线程的退出代码设置为线程函数的返回值；
系统递减线程内核对象的引用计数。

2、 ExitThread函数。

可以通过在线程中调用ExitThread函数，来强制终止自身线程的运行。原型为：
VOID ExitThread(DWORD dwExitCode);

该函数将终止自身线程的运行，并导致操作系统清除该线程使用的所有操作系统资源。但是，C++资源(如C++对象)将不被正确地撤销。由于这个原因，最好从线程函数返回，而不是通过调用ExitThread来返回。

3、 TerminateThread函数。调用TerminateThread函数将终止指定线程的运行，原型为：

BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);

//HANDLE hThread—将要终止的线程的句柄

//DWORD dwExitCode—传递给将要终止的线程的退出代码

与ExitThread不同，ExitThread是撤销自身线程，而TerminateThread能够撤销任何线程。

要注意的是，TerminateThread是异步运行的函数，也就是说，它告诉系统要终止指定线程的运行，但是该函数返回后，并不能保证指定的线程已经撤销，如果要确切地知道被指定的线程是否已经被撤销，请调用WaitForSingleObject等函数。
4、 进程终止运行(主线程退出)
5、 线程 终止运行时，会发生下列操作：
线程拥有的所有USER对象句柄均被释放。在Windows中，线程所创建的大部分对象归它的进程所有。但是，线程也可以拥有两个USER对象：窗口和钩子。当创建这些对象的线程终止运行时，系统会自动释放这些对象。其它对对象只有在进程终止时才被释放；
线程的退出代码从STILL_ACTIVE改为线程函数返回值或者传递给ExitThread或者TerminateThread的代码；
线程内核对象的状态变为通知(信号)状态；
如果线程是进程中最后一个活动线程，进程也被终止；
线程内核对象的使用计数递减1。
例1：
 线程的正常退出。注意！在线程中new出来的资源并不能随着线程退出而自动释放！！！

 class CTest
 {
 private:
     int m_iId;
 public:
     CTest(int iId)
     {
         m_iId=iId;
     }
     virtual ~CTest()
     {
         TRACE("ID:%d ~CTest()\n",m_iId);
     }
 };
 
 DWORD WINAPI SubThread(LPVOID lpParam)
 {
     CTest obj(1),*pObj;
     pObj=new CTest(2); //注意，堆分配的资源并不随着线程的退出而自动释放
     Sleep(500);
     return 999;
 }
 
 void MainThread()
 {
     DWORD dwRet;
     HANDLE hThread=CreateThread(NULL,0,SubThread,NULL,0,NULL);
     GetExitCodeThread(hThread,&dwRet);
     TRACE("SubThread exitcode:%d\n",dwRet);//很可能为STILL_ACTIVE
     Sleep(1000);
     GetExitCodeThread(hThread,&dwRet);
     TRACE("SubThread exitcode:%d\n",dwRet);//很可能为999
     CloseHandle(hThread);
 }

例2：
自身调用ExitThread退出线程

 class CTest
 {
 private:
     int m_iId;
 public:
     CTest(int iId)
     {
         m_iId=iId;
     }
     virtual ~CTest()
     {
         TRACE("ID:%d ~CTest()\n",m_iId);
     }
 };
 
 DWORD WINAPI SubThread(LPVOID lpParam)
 {
     CTest obj(1),*pObj;
     pObj=new CTest(2); //注意，堆分配的资源并不随着线程的退出而自动释放
     Sleep(500);
     ExitThread(1000); //接下来的返回语句将得不到执行，obj也不会被析构
     return 999;
 }
 
 void MainThread()
 {
     DWORD dwRet;
     HANDLE hThread=CreateThread(NULL,0,SubThread,NULL,0,NULL);
     GetExitCodeThread(hThread,&dwRet);
     TRACE("SubThread exitcode:%d\n",dwRet);//很可能为STILL_ACTIVE
     Sleep(1000);
     GetExitCodeThread(hThread,&dwRet);
     TRACE("SubThread exitcode:%d\n",dwRet);//很可能为1000
     CloseHandle(hThread);
 }

例3：
调用TerminateThread来终止另外一个线程的运行。

 DWORD WINAPI SubThread(LPVOID lpParam)
 {
     CTest obj(1),*pObj;
     pObj=new CTest(2); //注意，堆分配的资源并不随着线程的退出而自动释放
     Sleep(500);
     return 999;
 }
 
 void MainThread()
 {
     DWORD dwRet;
     HANDLE hThread=CreateThread(NULL,0,SubThread,NULL,0,NULL);
     GetExitCodeThread(hThread,&dwRet);
     TRACE("SubThread exitcode:%d\n",dwRet); //很可能为STILL_ACTIVE
     TerminateThread(hThread,1001); //强行终止线程hThread的运行
     //TerminateThread是异步函数，所以可能此时hThread并没撤销完毕。
     Sleep(500);
     GetExitCodeThread(hThread,&dwRet);
     TRACE("SubThread exitcode:%d\n",dwRet); //很可能为1001
     CloseHandle(hThread);
 }

3. 线程的暂停(挂起)与恢复运行
任何线程都可以调用 SuspendThread()来暂停另一个线程的运行(只要拥有线程的句柄)。原型为：
DWORD SuspendThread(HANDLE hThread);
返回值是前一次暂停计数，一个线程能够被暂停的最多次数是MAXIMUM_SUSPEND_COUNT,
参数HANDLE hThread表示将要被挂起的线程
调用 ResumeThread()可以让挂起的线程恢复运行。原型为：
DWORD ResumeThread(HANDLE hThread);
返回值是前一次暂停计数，参数HANDLE hThread表示将要被恢复的线程
例：

 #include <windows.h>
 #include <stdio.h>

 DWORD WINAPI ThreadProc(LPVOID lpParam)
 {
     printf("subThread: lpParam is %d\n", lpParam);
     return 0;
 }

 void main()
 {
     HANDLE hThread=CreateThread(NULL, 0, ThreadProc, (LPVOID)123, CREATE_SUSPENDED, 0);
     printf("a new thread is created\n");
     ResumeThread(hThread);
     Sleep(1000);
     CloseHandle(hThread);
 }

4. 线程的优先级

 HANDLE g_hThread1=NULL;
 HANDLE g_hThread2=NULL;
 
 void ConsumeCPU()
 {
     char szBuf[8192];
     for(int i=0;i<200000;i++)
     {
         sprintf(szBuf,"%d",rand());
         memset(szBuf,0,sizeof(szBuf));
     }
 }

 DWORD WINAPI SubThread(LPVOID lpParam)
 {
     int iLoop=0;
     while(TRUE)
     {
         ConsumeCPU();
         TRACE("Thread %X loop:%d\n",GetCurrentThreadId(),iLoop++);
     }
     return 0;
 }

 void CMy0621Dlg::OnOK()
 {
     g_hThread1=CreateThread(NULL,0,SubThread,NULL,0,NULL);
     g_hThread2=CreateThread(NULL,0,SubThread,NULL,0,NULL);
     SetThreadPriority(g_hThread1,THREAD_PRIORITY_LOWEST);
     SetThreadPriority(g_hThread2,THREAD_PRIORITY_LOWEST);
 }

 void CMy0621Dlg::OnButtonReduce()
 {
     SetThreadPriority(g_hThread1,THREAD_PRIORITY_IDLE);
 }

 void CMy0621Dlg::OnButtonRestore()
 {
     SetThreadPriority(g_hThread1,THREAD_PRIORITY_LOWEST);
 }

2. 获取线程退出码

BOOL   GetExitCodeThread (

       HANDLE         hThread,                  // in,线程handle,也就是CreateThread()的返回值

       LPDWORD      lpExitCode               //out,存储线程结束代码,也就是线程的返回值

);

说明: 此函数调用成功返回TRUE,失败返回FALSE,只表示这个函数是否调用成功而己.

        不能根据返回值来判断一个线程是否结束,而要根据 lpExitCode的值来确定,

        lpExitCode  值STILL_ACTIVE 表示线程正在运行.

            若线程己经结束,则lpExitCode中存储指定线程的返回值.

例:

/*
 * ExitCode.c
 *
 * Sample code for "Multithreading Applications in Win32"
 * This is from Chapter 2, Listing 2-2
 *
 * Start two threads and try to exit
 * when the user presses a key.
 */

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>

DWORD WINAPI ThreadFunc(LPVOID);

int main()
{
    HANDLE hThrd1;
    HANDLE hThrd2;
    DWORD exitCode1 = 0;
    DWORD exitCode2 = 0;
    DWORD threadId;

    //创建成功,返回一个HANDLE,对于此线程的操作函数,几乎都使用此HANDLE
    hThrd1 = CreateThread(NULL,
        0,                                            //堆栈大小,0取默认值1MB
        ThreadFunc,                          //线程函数地址
        (LPVOID)1,                           //线程的传入参数
        0,                                          //0 表示线程一旦创建 立即执行
        &threadId );                         //线程ID,一般为 向线程发送消息时用,
    if (hThrd1)
        printf("Thread 1 launched/n");

    //
    hThrd2 = CreateThread(NULL,
        0,
        ThreadFunc,
        (LPVOID)2,
        0,
        &threadId );
    if (hThrd2)
        printf("Thread 2 launched/n");


    // Keep waiting until both calls to
    // GetExitCodeThread succeed AND
    // neither of them returns STILL_ACTIVE.
    // This method is not optimal - we'll
    // see the correct way in Chapter 3.
    for (;;)
    {
        printf("Press any key to exit../n");
        getch();                                       // 按任意键继续

                      // 刺探 指定线程(通过线程的HANDLE) 是否己经结束, 
                     //exitCode1中存储线程状态,若正在运行,值为STILL_ACTIVE 
                    //若己经结束,值为 线程的返回值(即 return 后的值)
        GetExitCodeThread(hThrd1, &exitCode1);    
        GetExitCodeThread(hThrd2, &exitCode2);
        if ( exitCode1 == STILL_ACTIVE )
            puts("Thread 1 is still running!");
        if ( exitCode2 == STILL_ACTIVE )
            puts("Thread 2 is still running!");
        if ( exitCode1 != STILL_ACTIVE
            && exitCode2 != STILL_ACTIVE )
            break;
    }

    CloseHandle(hThrd1);                //线程核心对象的引用计数 减1
    CloseHandle(hThrd2);

    printf("Thread 1 returned %d/n", exitCode1);
    printf("Thread 2 returned %d/n", exitCode2);

    return EXIT_SUCCESS;
}


/*
 * Take the startup value, do some simple math on it,
 * and return the calculated value.
 */
DWORD WINAPI ThreadFunc(LPVOID n)
{
    Sleep((DWORD)n*1000*2);
    return (DWORD)n * 10;
}

//以上代码,存储进text文件,以.c为扩展名,拖进VC 6.0,编译,运行.

3. WaitForSingleObject()

在多线程下面，有时候我们会希望等待某一线程完成了再继续做其他事情，要实现这个目的，可以使用Windows API函数WaitForSingleObject，或者WaitForMultipleObjects。这两个函数都会等待Object被标为有信号(signaled)时才返回的。
那么，什么是信号呢？
简单来说，Windows下创建的Object都会被赋予一个状态量。如果Object被激活了，或者正在使用，那么该Object就是无信号，也就是不可用；另一方面，如果Object可用了，那么它就恢复有信号了。

这两个函数的优点是它们在等待的过程中会进入一个非常高效沉睡状态，只占用极少的CPU时间片。（这两个函数都是在内核状态下等待内核对象，不切换到用户模式下，因而效率很高）

1. 格式

DWORD WaitForSingleObject( HANDLE hHandle, DWORDdwMilliseconds);

有两个参数，分别是THandle和Timeout(毫秒单位)。

如果想要等待一条线程，那么你需要指定线程的Handle，以及相应的Timeout时间。当然，如果你想无限等待下去，Timeout参数可以指定系统常量INFINITE。

2. 使用对象

它可以等待如下几种类型的对象：

Event，Mutex，Semaphore，Process，Thread 

3. 返回类型

有三种返回类型：

WAIT_OBJECT_0, 表示等待的对象有信号（对线程来说，表示执行结束）；

 WAIT_TIMEOUT, 表示等待指定时间内，对象一直没有信号（线程没执行完）；

WAIT_ABANDONED 表示对象有信号，但还是不能执行  一般是因为未获取到锁或其他原因

示例：

 <span style="font-family:Times New Roman;">#include <windows.h>
 #include <stdio.h>
 #include <iostream.h>

 //声明函数  创建线程
 DWORD WINAPI FunProc( LPVOID lpParameter);

 void main()
 {
     HANDLE hThread;
     hThread=CreateThread(NULL,0,FunProc,NULL,0,NULL);
     DWORD dwRet=WaitForSingleObject(hThread, 1);
     if(dwRet==WAIT_OBJECT_0)
     {
         printf("创建的线程执行结束\n");
     }
     if(dwRet==WAIT_TIMEOUT)
     {
         printf("等待超时\n");
     }
     if(dwRet==WAIT_ABANDONED)
     {
         printf("Abandoned\n");
     }
     CloseHandle(hThread);
 }

 DWORD WINAPI FunProc( LPVOID lpParameter )
 {
     int i=1;
     for(; i<1000; i++)
     {
         printf("%d  ", i);
         if(! (i%10))
             printf("\n");
     }
     return 0;
 }</span>

WaitForMultipleObjecct

相对来说，WaitForMultipleObjects要复杂点点

格式为：

DWORD WaitForMultipleObjects(DWORD nCount, CONST HANDLE *lpHandles, BOOLfWaitAll, DWORDdwMilliseconds);

四个参数分别是：

1. nCount，DWORD类型，用于指定句柄数组的数量
2. lphObjects，Pointer类型，用于指定句柄数组的内存地址
3. fWaitAll，Boolean类型， True表示函数等待所有指定句柄的Object有信号为止
4. dwTimeout，DWORD类型，用于指定等待的Timeout时间，单位毫秒，可以是INFINITE

当WaitForMultipleObjects等待多个内核对象的时候，如果它的bWaitAll 参数设置为false。其返回值减去WAIT_OBJECT_0 就是参数lpHandles数组的序号。如果同时有多个内核对象被触发，这个函数返回的只是其中序号最小的那个。

如果为TRUE 则等待所有信号量有效在往下执行。（FALSE 当有其中一个信号量有效时就向下执行）

问题就在这里，我们如何可以获取所有被同时触发的内核对象。

举个例子：我们需要在一个线程中处理从完成端口、数据库、和可等待定时器来的数据。一个典型的实现方法就是：用WaitForMultipleObjects等待所有的这些事件。如果完成端口，数据库发过来的数据量非常大，可等待定时器时间也只有几十毫秒。那么这些事件同时触发的几率可以说非常大，我们不希望丢弃任何一个被触发的事件。那么如何能高效地实现这一处理呢？ 　　

MSDN中有一句非常重要的描述，它可以说是WaitForMultipleObjects用法的精髓：The function modifies the state of some types of synchronization objects. Modification occurs only for the object or objects whose signaled state caused the function to return. For example, the count of a semaphore object is decreased by one. When bWaitAll is FALSE, and multiple objects are in the signaled state, the function chooses one of the objects to satisfy the wait; the states of the objects not selected are unaffected. 　　

多个内核对象被触发时，WaitForMultipleObjects选择其中序号最小的返回。而WaitForMultipleObjects它只会改变使它返回的那个内核对象的状态。

这儿又会产生一个问题，如果序号最小的那个对象频繁被触发，那么序号比它大的内核对象将得不到被处理的机会。为了解决这一问题，可以采用双WaitForMultipleObjects检测机制来实现。见下面的例子： 

 <span style="font-family:Times New Roman;">DWORD WINAPI ThreadProc(LPVOID lpParameter)
 {
     DWORD dwRet = 0;
     int nIndex = 0;
     while(1)
     {
         dwRet = WaitForMultipleObjects(nCount,pHandles,false,INFINITE);
         switch(dwRet)
         {
             case WAIT_TIMEOUT:
                 break;
             case WAIT_FAILED:
                 return 1;
             default:
             {
                 nIndex = dwRet - WAIT_OBJECT_0;
                 ProcessHanlde(nIndex++); 　　//同时检测其他的事件
                 while(nIndex < nCount) //nCount事件对象总数
                 {
                     dwRet = WaitForMultipleObjects(nCount - nIndex,&pHandles[nIndex],false,0);
                     switch(dwRet)
                     {
                         case WAIT_TIMEOUT:
                             nIndex = nCount; //退出检测,因为没有被触发的对象了.
                             break;
                         case WAIT_FAILED:
                             return 1;
                         default:
                         {
                             nIndex = dwRet - WAIT_OBJECT_0;
                             ProcessHanlde(nIndex++);
                         }
                             break;
                     }//switch结束
                 }//while结束
             }//default结束
                 break;
         }//switch结束

     }//while结束
     return 0;
 }</span>

MSDN对于这个函数的返回值还有一句话： 　　

Return Values 　　If the function succeeds, the return value indicates the event that caused the function to return. This value can be one of the following. 　　ValueMeaning 　　WAIT_OBJECT_0 to (WAIT_OBJECT_0 + nCount – 1)If bWaitAll is TRUE, the return value indicates that the state of all specified objects is signaled. 　　If bWaitAll is FALSE, the return value minus WAIT_OBJECT_0 indicates the lpHandles array index of the object that satisfied the wait. If more than one object became signalled during the call, this is the array index of the signalled object with the smallest index value of all the signalled objects. 　　WAIT_ABANDONED_0 to (WAIT_ABANDONED_0 + nCount – 1)If bWaitAll is TRUE, the return value indicates that the state of all specified objects is signaled and at least one of the objects is an abandoned mutex object. 　　If bWaitAll is FALSE, the return value minus WAIT_ABANDONED_0 indicates the lpHandles array index of an abandoned mutex object that satisfied the wait. 　　WAIT_TIMEOUTThe time-out interval elapsed and the conditions specified by the bWaitAll parameter are not satisfied. 　　

返回值

如果函数成功，返回值表示该事件导致该函数返回。

这个值可以是下列之一：

WAIT_OBJECT_0到WAIT_OBJECT_0 + nCount - 1

      如果bWaitAll为TRUE，则返回值表明所有指定对象的状态信号

      如果bWaitAll为FALSE，则返回值减去不是WAIT_OBJECT_0表示lpHandles数组的对象的满意指数的等待。如果多个对象在通话过程中信号成为有信号状态，这是与所有的信号对象的最小索引值的信号对象的数组索引。

WAIT_ABANDONED_0至WAIT_ABANDONED_0 + nCount - 1

     如果bWaitAll为TRUE，则返回值表明所有指定对象的状态，至少是暗示的对象之一，是一个废弃的互斥对象。 

     如果bWaitAll为FALSE，则返回值减去WAIT_ABANDONED_0表示lpHandles数组的一个废弃的互斥对象的满意指数的等待。 　　

WAIT_TIMEOUTThe超时间隔已过，由bWaitAll参数指定的条件得不到满足。