【转帖】深入浅出Win32多线程程序设计

「爱情、让人受尽委屈。」 2022-08-24 00:44 145阅读 0赞

深入浅出Win32多线程程序设计之线程控制

作者： [宋宝华][Link 1] 阅读人次： 752 文章来源： [天极开发][Link 2] 发布时间：2006-8-25 [网友评论(3)条][3]

WIN32线程控制主要实现线程的创建、终止、挂起和恢复等操作，这些操作都依赖于WIN32提供的一组API和具体编译器的C运行时库函数。  
  
　　1.线程函数  
  
　　在启动一个线程之前，必须为线程编写一个全局的线程函数，这个线程函数接受一个32位的LPVOID作为参数，返回一个UINT，线程函数的结构为：

<table> 
 <tbody> 
  <tr> 
   <td>UINT ThreadFunction(LPVOID pParam)<br>{ <br>　//线程处理代码<br>　return0;<br>}</td> 
  </tr> 
 </tbody> 
</table>

在线程处理代码部分通常包括一个死循环，该循环中先等待某事情的发生，再处理相关的工作：

<table> 
 <tbody> 
  <tr> 
   <td>while(1)<br>{ <br>　WaitForSingleObject(…,…);//或WaitForMultipleObjects(…)<br>　//Do something<br>}</td> 
  </tr> 
 </tbody> 
</table>

一般来说，C++的类成员函数不能作为线程函数。这是因为在类中定义的成员函数，编译器会给其加上this指针。请看下列程序：

<table> 
 <tbody> 
  <tr> 
   <td>#include "windows.h"<br>#include &lt;process.h&gt;<br>class ExampleTask <br>{ <br>　public: <br>　　void taskmain(LPVOID param); <br>　　void StartTask(); <br>}; <br>void ExampleTask::taskmain(LPVOID param) <br>{} <br><br>void ExampleTask::StartTask() <br>{ <br>　_beginthread(taskmain,0,NULL);<br>} <br><br>int main(int argc, char* argv[])<br>{ <br>　ExampleTask realTimeTask;<br>　realTimeTask.StartTask();<br>　return 0;<br>}</td> 
  </tr> 
 </tbody> 
</table>

程序编译时出现如下错误：

<table> 
 <tbody> 
  <tr> 
   <td>error C2664: '_beginthread' : cannot convert parameter 1 from 'void (void *)' to 'void (__cdecl *)(void *)'<br>None of the functions with this name in scope match the target type</td> 
  </tr> 
 </tbody> 
</table>

再看下列程序：

<table> 
 <tbody> 
  <tr> 
   <td>#include "windows.h"<br>#include &lt;process.h&gt;<br>class ExampleTask <br>{ <br>　public: <br>　　void taskmain(LPVOID param); <br>}; <br><br>void ExampleTask::taskmain(LPVOID param) <br>{} <br><br>int main(int argc, char* argv[])<br>{ <br>　ExampleTask realTimeTask;<br>　_beginthread(ExampleTask::taskmain,0,NULL);<br>　return 0;<br>}</td> 
  </tr> 
 </tbody> 
</table>

程序编译时会出错：

如果一定要以类成员函数作为线程函数，通常有如下解决方案：  
  
　　（1）将该成员函数声明为static类型，去掉this指针；  
  
　　我们将上述二个程序改变为：

<table> 
 <tbody> 
  <tr> 
   <td>#include "windows.h"<br>#include &lt;process.h&gt;<br>class ExampleTask <br>{ <br>　public: <br>　　void static taskmain(LPVOID param); <br>　　void StartTask(); <br>}; <br><br>void ExampleTask::taskmain(LPVOID param) <br>{} <br><br>void ExampleTask::StartTask() <br>{ <br>　_beginthread(taskmain,0,NULL);<br>} <br><br>int main(int argc, char* argv[])<br>{ <br>　ExampleTask realTimeTask;<br>　realTimeTask.StartTask();<br>　return 0;<br>}<br>和<br>#include "windows.h"<br>#include &lt;process.h&gt;<br>class ExampleTask <br>{ <br>　public: <br>　　void static taskmain(LPVOID param); <br>}; <br><br>void ExampleTask::taskmain(LPVOID param) <br>{} <br><br>int main(int argc, char* argv[])<br>{ <br>　_beginthread(ExampleTask::taskmain,0,NULL);<br>　return 0;<br>}</td> 
  </tr> 
 </tbody> 
</table>

均编译通过。  
  
　　将成员函数声明为静态虽然可以解决作为线程函数的问题，但是它带来了新的问题，那就是static成员函数只能访问static成员。解决此问题的一种途径是可以在调用类静态成员函数（线程函数）时将this指针作为参数传入，并在改线程函数中用强制类型转换将this转换成指向该类的指针，通过该指针访问非静态成员。  
  
　　（2）不定义类成员函数为线程函数，而将线程函数定义为类的友元函数。这样，线程函数也可以有类成员函数同等的权限；  
  
　　我们将程序修改为：

<table> 
 <tbody> 
  <tr> 
   <td>#include "windows.h"<br>#include &lt;process.h&gt;<br>class ExampleTask <br>{ <br>　public: <br>　　friend void taskmain(LPVOID param); <br>　　void StartTask(); <br>}; <br><br>void taskmain(LPVOID param) <br>{ <br>　ExampleTask * pTaskMain = (ExampleTask *) param; <br>　//通过pTaskMain指针引用 <br>} <br><br>void ExampleTask::StartTask() <br>{ <br>　_beginthread(taskmain,0,this);<br>}<br>int main(int argc, char* argv[])<br>{ <br>　ExampleTask realTimeTask;<br>　realTimeTask.StartTask();<br>　return 0;<br>}</td> 
  </tr> 
 </tbody> 
</table>

（3）可以对非静态成员函数实现回调，并访问非静态成员，此法涉及到一些高级技巧，在此不再详述。

深入浅出Win32多线程程序设计之线程控制

作者： [宋宝华][Link 1] 阅读人次： 751 文章来源： [天极开发][Link 2] 发布时间：2006-8-25 [网友评论(3)条][3 1]

2.创建线程  
  
　　进程的主线程由操作系统自动生成，Win32提供了CreateThread API来完成用户线程的创建，该API的原型为：

<table> 
 <tbody> 
  <tr> 
   <td>HANDLE CreateThread(<br>　LPSECURITY_ATTRIBUTES lpThreadAttributes,//Pointer to a SECURITY_ATTRIBUTES structure<br>　SIZE_T dwStackSize, //Initial size of the stack, in bytes.<br>　LPTHREAD_START_ROUTINE lpStartAddress,<br>　LPVOID lpParameter, //Pointer to a variable to be passed to the thread<br>　DWORD dwCreationFlags, //Flags that control the creation of the thread<br>　LPDWORD lpThreadId //Pointer to a variable that receives the thread identifier<br>);</td> 
  </tr> 
 </tbody> 
</table>

如果使用C/C++语言编写多线程应用程序，一定不能使用操作系统提供的CreateThread API，而应该使用C/C++运行时库中的\_beginthread（或\_beginthreadex），其函数原型为：

<table> 
 <tbody> 
  <tr> 
   <td>uintptr_t _beginthread( <br>　void( __cdecl *start_address )( void * ), //Start address of routine that begins execution of new thread<br>　unsigned stack_size, //Stack size for new thread or 0.<br>　void *arglist //Argument list to be passed to new thread or NULL<br>);<br>uintptr_t _beginthreadex( <br>　void *security,//Pointer to a SECURITY_ATTRIBUTES structure<br>　unsigned stack_size,<br>　unsigned ( __stdcall *start_address )( void * ),<br>　void *arglist,<br>　unsigned initflag,//Initial state of new thread (0 for running or CREATE_SUSPENDED for suspended); <br>　unsigned *thrdaddr <br>);</td> 
  </tr> 
 </tbody> 
</table>

\_beginthread函数与Win32 API 中的CreateThread函数类似，但有如下差异：  
  
　　（1）通过\_beginthread函数我们可以利用其参数列表arglist将多个参数传递到线程；  
  
　　（2）\_beginthread 函数初始化某些 C 运行时库变量，在线程中若需要使用 C 运行时库。  
  
　　3.终止线程  
  
　　线程的终止有如下四种方式：  
  
　　（1）线程函数返回；  
  
　　（2）线程自身调用ExitThread 函数即终止自己，其原型为：

<table> 
 <tbody> 
  <tr> 
   <td>VOID ExitThread(UINT fuExitCode ); </td> 
  </tr> 
 </tbody> 
</table>

它将参数fuExitCode设置为线程的退出码。  
  
　　注意：如果使用C/C++编写代码，我们应该使用C/C++运行时库函数\_endthread (\_endthreadex)终止线程，决不能使用ExitThread！  
\_endthread 函数对于线程内的条件终止很有用。例如，专门用于通信处理的线程若无法获取对通信端口的控制，则会退出。  
  
　　（3）同一进程或其他进程的线程调用TerminateThread函数，其原型为：

<table> 
 <tbody> 
  <tr> 
   <td>BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode); </td> 
  </tr> 
 </tbody> 
</table>

该函数用来结束由hThread参数指定的线程，并把dwExitCode设成该线程的退出码。当某个线程不再响应时，我们可以用其他线程调用该函数来终止这个不响应的线程。  
  
　　（4）包含线程的进程终止。  
  
　　最好使用第1种方式终止线程，第2~4种方式都不宜采用。  
  
　　4.挂起与恢复线程  
  
　　当我们创建线程的时候，如果给其传入CREATE\_SUSPENDED标志，则该线程创建后被挂起，我们应使用ResumeThread恢复它：

<table> 
 <tbody> 
  <tr> 
   <td>DWORD ResumeThread(HANDLE hThread); </td> 
  </tr> 
 </tbody> 
</table>

如果ResumeThread函数运行成功，它将返回线程的前一个暂停计数，否则返回0x FFFFFFFF。  
  
　　对于没有被挂起的线程，程序员可以调用SuspendThread函数强行挂起之：

<table> 
 <tbody> 
  <tr> 
   <td>DWORD SuspendThread(HANDLE hThread);</td> 
  </tr> 
 </tbody> 
</table>

一个线程可以被挂起多次。线程可以自行暂停运行，但是不能自行恢复运行。如果一个线程被挂起n次，则该线程也必须被恢复n次才可能得以执行。

深入浅出Win32多线程程序设计之线程控制

作者： [宋宝华][Link 1] 阅读人次： 753 文章来源： [天极开发][Link 2] 发布时间：2006-8-25 [网友评论(3)条][3]

5.设置线程优先级  
  
　　当一个线程被首次创建时，它的优先级等同于它所属进程的优先级。在单个进程内可以通过调用SetThreadPriority函数改变线程的相对优先级。一个线程的优先级是相对于其所属进程的优先级而言的。

<table> 
 <tbody> 
  <tr> 
   <td>BOOL SetThreadPriority(HANDLE hThread, int nPriority); </td> 
  </tr> 
 </tbody> 
</table>

其中参数hThread是指向待修改优先级线程的句柄，线程与包含它的进程的优先级关系如下：  
  
　　　线程优先级 = 进程类基本优先级 + 线程相对优先级  
  
　　进程类的基本优先级包括：  
  
　　（1）实时：REALTIME\_PRIORITY\_CLASS；  
  
　　（2）高：HIGH \_PRIORITY\_CLASS；  
  
　　（3）高于正常：ABOVE\_NORMAL\_PRIORITY\_CLASS；  
  
　　（4）正常：NORMAL \_PRIORITY\_CLASS；  
  
　　（5）低于正常：BELOW\_ NORMAL \_PRIORITY\_CLASS；  
  
　　（6）空闲：IDLE\_PRIORITY\_CLASS。  
  
　　我们从Win32任务管理器中可以直观的看到这六个进程类优先级，如下图：

线程的相对优先级包括：  
  
　　（1）空闲：THREAD\_PRIORITY\_IDLE；  
  
　　（2）最低线程：THREAD\_PRIORITY\_LOWEST；  
  
　　（3）低于正常线程：THREAD\_PRIORITY\_BELOW\_NORMAL；  
  
　　（4）正常线程：THREAD\_PRIORITY\_ NORMAL (缺省)；  
  
　　（5）高于正常线程：THREAD\_PRIORITY\_ABOVE\_NORMAL；  
  
　　（6）最高线程：THREAD\_PRIORITY\_HIGHEST；  
  
　　（7）关键时间：THREAD\_PRIOTITY\_CRITICAL。  
  
　　下图给出了进程优先级和线程相对优先级的映射关系：

例如：

<table> 
 <tbody> 
  <tr> 
   <td>HANDLE hCurrentThread = GetCurrentThread();<br>//获得该线程句柄<br>SetThreadPriority(hCurrentThread, THREAD_PRIORITY_LOWEST); </td> 
  </tr> 
 </tbody> 
</table>

6.睡眠

<table> 
 <tbody> 
  <tr> 
   <td>VOID Sleep(DWORD dwMilliseconds);</td> 
  </tr> 
 </tbody> 
</table>

该函数可使线程暂停自己的运行，直到dwMilliseconds毫秒过去为止。它告诉系统，自身不想在某个时间段内被调度。  
  
　　7.其它重要API  
  
　　获得线程优先级  
  
　　一个线程被创建时，就会有一个默认的优先级，但是有时要动态地改变一个线程的优先级，有时需获得一个线程的优先级。

<table> 
 <tbody> 
  <tr> 
   <td>Int GetThreadPriority (HANDLE hThread);</td> 
  </tr> 
 </tbody> 
</table>

如果函数执行发生错误，会返回THREAD\_PRIORITY\_ERROR\_RETURN标志。如果函数成功地执行，会返回优先级标志。  
  
　　获得线程退出码

<table> 
 <tbody> 
  <tr> 
   <td>BOOL WINAPI GetExitCodeThread(<br>　HANDLE hThread,<br>　LPDWORD lpExitCode<br>);</td> 
  </tr> 
 </tbody> 
</table>

如果执行成功，GetExitCodeThread返回TRUE，退出码被lpExitCode指向内存记录；否则返回FALSE，我们可通过GetLastError()获知错误原因。如果线程尚未结束，lpExitCode带回来的将是STILL\_ALIVE。

<table> 
 <tbody> 
  <tr> 
   <td>获得/设置线程上下文<br>BOOL WINAPI GetThreadContext(<br>　HANDLE hThread,<br>　LPCONTEXT lpContext<br>);<br>BOOL WINAPI SetThreadContext(<br>　HANDLE hThread,<br>　CONST CONTEXT *lpContext<br>);</td> 
  </tr> 
 </tbody> 
</table>

由于GetThreadContext和SetThreadContext可以操作CPU内部的寄存器，因此在一些高级技巧的编程中有一定应用。譬如，调试器可利用GetThreadContext挂起被调试线程获取其上下文，并设置上下文中的标志寄存器中的陷阱标志位，最后通过SetThreadContext使设置生效来进行单步调试。  
  
　　8.实例  
  
　　以下程序使用CreateThread创建两个线程，在这两个线程中Sleep一段时间，主线程通过GetExitCodeThread来判断两个线程是否结束运行：

<table> 
 <tbody> 
  <tr> 
   <td>#define WIN32_LEAN_AND_MEAN<br>#include &lt;stdio.h&gt;<br>#include &lt;stdlib.h&gt;<br>#include &lt;windows.h&gt;<br>#include &lt;conio.h&gt;<br><br>DWORD WINAPI ThreadFunc(LPVOID);<br><br>int main()<br>{ <br>　HANDLE hThrd1;<br>　HANDLE hThrd2;<br>　DWORD exitCode1 = 0;<br>　DWORD exitCode2 = 0;<br>　DWORD threadId;<br><br>　hThrd1 = CreateThread(NULL, 0, ThreadFunc, (LPVOID)1, 0, &amp;threadId );<br>　if (hThrd1)<br>　　printf("Thread 1 launched/n");<br><br>　hThrd2 = CreateThread(NULL, 0, ThreadFunc, (LPVOID)2, 0, &amp;threadId );<br>　if (hThrd2)<br>　　printf("Thread 2 launched/n");<br><br>　// Keep waiting until both calls to GetExitCodeThread succeed AND<br>　// neither of them returns STILL_ACTIVE.<br>　for (;;)<br>　{ <br>　　printf("Press any key to exit../n");<br>　　getch();<br><br>　　GetExitCodeThread(hThrd1, &amp;exitCode1);<br>　　GetExitCodeThread(hThrd2, &amp;exitCode2);<br>　　if ( exitCode1 == STILL_ACTIVE )<br>　　　puts("Thread 1 is still running!");<br>　　if ( exitCode2 == STILL_ACTIVE )<br>　　　puts("Thread 2 is still running!");<br>　　if ( exitCode1 != STILL_ACTIVE &amp;&amp; exitCode2 != STILL_ACTIVE )<br>　　　break;<br>　}<br><br>　CloseHandle(hThrd1);<br>　CloseHandle(hThrd2);<br><br>　printf("Thread 1 returned %d/n", exitCode1);<br>　printf("Thread 2 returned %d/n", exitCode2);<br><br>　return EXIT_SUCCESS;<br>}<br><br>/*<br>* Take the startup value, do some simple math on it,<br>* and return the calculated value.<br>*/<br>DWORD WINAPI ThreadFunc(LPVOID n)<br>{ <br>　Sleep((DWORD)n*1000*2);<br>　return (DWORD)n * 10;<br>}</td> 
  </tr> 
 </tbody> 
</table>

通过下面的程序我们可以看出多线程程序运行顺序的难以预料以及WINAPI的CreateThread函数与C运行时库的\_beginthread的差别：

<table> 
 <tbody> 
  <tr> 
   <td>#define WIN32_LEAN_AND_MEAN<br>#include &lt;stdio.h&gt;<br>#include &lt;stdlib.h&gt;<br>#include &lt;windows.h&gt;<br><br>DWORD WINAPI ThreadFunc(LPVOID);<br><br>int main()<br>{ <br>　HANDLE hThrd;<br>　DWORD threadId;<br>　int i;<br><br>　for (i = 0; i &lt; 5; i++)<br>　{ <br>　　hThrd = CreateThread(NULL, 0, ThreadFunc, (LPVOID)i, 0, &amp;threadId);<br>　　if (hThrd)<br>　　{ <br>　　　printf("Thread launched %d/n", i);<br>　　　CloseHandle(hThrd);<br>　　}<br>　}<br>　// Wait for the threads to complete.<br>　Sleep(2000);<br><br>　return EXIT_SUCCESS;<br>}<br><br>DWORD WINAPI ThreadFunc(LPVOID n)<br>{ <br>　int i;<br>　for (i = 0; i &lt; 10; i++)<br>　　printf("%d%d%d%d%d%d%d%d/n", n, n, n, n, n, n, n, n);<br>　return 0;<br>}</td> 
  </tr> 
 </tbody> 
</table>

运行的输出具有很大的随机性，这里摘取了几次结果的一部分（几乎每一次都不同）：

如果我们使用标准C库函数而不是多线程版的运行时库，则程序可能输出"3333444444"这样的结果，而使用多线程运行时库后，则可避免这一问题。  
  
　　下列程序在主线程中创建一个SecondThread，在SecondThread线程中通过自增对Counter计数到1000000，主线程一直等待其结束：

<table> 
 <tbody> 
  <tr> 
   <td>#include &lt;Win32.h&gt;<br>#include &lt;stdio.h&gt;<br>#include &lt;process.h&gt;<br><br>unsigned Counter;<br>unsigned __stdcall SecondThreadFunc(void *pArguments)<br>{ <br>　printf("In second thread.../n");<br><br>　while (Counter &lt; 1000000)<br>　　Counter++;<br><br>　_endthreadex(0);<br>　return 0;<br>}<br><br>int main()<br>{ <br>　HANDLE hThread;<br>　unsigned threadID;<br><br>　printf("Creating second thread.../n");<br><br>　// Create the second thread.<br>　hThread = (HANDLE)_beginthreadex(NULL, 0, &amp;SecondThreadFunc, NULL, 0, &amp;threadID);<br><br>　// Wait until second thread terminates <br>　WaitForSingleObject(hThread, INFINITE);<br>　printf("Counter should be 1000000; it is-&gt; %d/n", Counter);<br>　// Destroy the thread object.<br>　CloseHandle(hThread);<br>}<br></td> 
  </tr> 
 </tbody> 
</table>

[Link 1]: http://www.bccn.net/ShowAuthor.asp?ChannelID=1&AuthorName=宋宝华
[Link 2]: http://www.bccn.net/ShowCopyFrom.asp?ChannelID=1&SourceName=天极开发
[3]: http://www.bccn.net/article/comment/?/=4318.html
[3 1]: http://www.bc-cn.net/article/comment/?/=4318.html