多线程学习：win32多线程编程基本概念(转)

一、定义：

1.进程和线程的区别

进程：是程序的执行过程，具有动态性，即运行的程序就叫进程，不运行就叫程序 ，每个进程包含一到多个线程。
线程：系统中的最小执行单元，同一进程中有多个线程，线程可以共享资源，一旦出现共享资源，必须注意线程安全！！

先阐述一下进程和线程的概念和区别，这是一个许多大学老师也讲不清楚的问题。

　 　进程（process）是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位。程序只是一组指令的有序集合，它本身没有任何运行的含义，只是一个静态实体。而进程则不同，它是程序在某个数据集上的执行，是一个动态实体。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消，反映了一个程序在一定的数据集上运行的全部动态过程。

　　线程（thread）是进程的一个实体，是cpu调度和分派的基本单位。线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

　 　线程和进程的关系是：线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出 并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、 一组寄存器和栈)。

     根据进程与线程的设置，操作系统大致分为如下类型： 

　　（1）单进程、单线程，ms-dos大致是这种操作系统；
　　（2）多进程、单线程，多数unix（及类unix的linux）是这种操作系统；
　　（3）多进程、多线程，win32（windows nt/2000/xp等）、solaris 2.x和os/2都是这种操作系统；
　　（4）单进程、多线程，vxworks是这种操作系统。

　　在操作系统中引入线程带来的主要好处是：

　　（1）在进程内创建、终止线程比创建、终止进程要快；
　　（2）同一进程内的线程间切换比进程间的切换要快，尤其是用户级线程间的切换。

    另外，线程的出现还因为以下几个原因：
　　（1）并发程序的并发执行，在多处理环境下更为有效。一个并发程序可以建立一个进程,而这个并发程序中的若干并发程序段就可以分别建立若干线程,使这些线程在不同的处理机上执行。
　　（2）每个进程具有独立的地址空间，而该进程内的所有线程共享该地址空间。这样可以解决父子进程模型中，子进程必须复制父进程地址空间的问题。
　　（3）线程对解决客户/服务器模型非常有效。

   win32进程间通信的方式主要有：

　　（1）剪贴板(clip board)；

　　（2）动态数据交换(dynamic data exchange)；

　　（3）部件对象模型(component object model)；

　　（4）文件映射(file mapping)；

　　（5）邮件槽(mail slots)；

　　（6）管道(pipes)；

　　（7）win32套接字(socket)；

　　（8）远程过程调用(remote procedure call)；

　　（9）wm_copydata消息(wm_copydata message)。

2、获取进程信息

　　在win32中，可使用在psapi .dll中提供的process status helper函数帮助我们获取进程信息。

　　（1）enumprocesses()函数可以获取进程的id，其原型为：

bool enumprocesses(dword * lpidprocess, dword cb, dword*cbneeded);

　　参数lpidprocess：一个足够大的dword类型的数组，用于存放进程的id值；

　　参数cb：存放进程id值的数组的最大长度，是一个dword类型的数据；

　　参数cbneeded：指向一个dword类型数据的指针，用于返回进程的数目；

　　函数返回值：如果调用成功，返回true，同时将所有进程的id值存放在lpidprocess参数所指向的数组中，进程个数存放在cbneeded参数所指向的变量中；如果调用失败，返回false。

　　（2）getmodulefilenameexa()函数可以实现通过进程句柄获取进程文件名，其原型为：

dword getmodulefilenameexa(handle hprocess, hmodule hmodule,lptstr lpstrfilename, dword nsize);

　　参数hprocess：接受进程句柄的参数，是handle类型的变量；

　　参数hmodule：指针型参数，在本文的程序中取值为null；

　　参数lpstrfilename：lptstr（表示指向字符/字符串的指针）类型的指针，用于接受主调函数传递来的用于存放进程名的字符数组指针；

　　参数nsize：lpstrfilename所指数组的长度；

　　函数返回值：如果调用成功，返回一个大于0的dword类型的数据，同时将hprocess所对应的进程名存放在lpstrfilename参数所指向的数组中；加果调用失败，则返回0。

　　通过下列代码就可以遍历系统中的进程，获得进程列表：

//获取当前进程总数
enumprocesses(process_, sizeof(process_ids), &num_processes);
//遍历进程
for (int i = 0; i < num_processes; i++)
{
　//根据进程id获取句柄 
　process[i] = openprocess(process_query_information | process_vm_read, 0,
　process_ids[i]);
　//通过句柄获取进程文件名
　if (getmodulefilenameexa(process[i], null, file_name, sizeof(filename)))
　　cout << filename << endl;
}

 

win32线程

　　win32靠线程的优先级（达到抢占式多任务的目的）及分配给线程的cpu时间来调度线程。win32本身的许多应用程序也利用了多线程的特性，如任务管理器等。
　　本质而言，一个处理器同一时刻只能执行一个线程（"微观串行"）。win32多任务机制使得cpu好像在同时处理多个任务一样，实现了"宏观并行"。

其多线程调度的机制为：

　　（1）运行一个线程，直到被中断或线程必须等待到某个资源可用；
　　（2）保存当前执行线程的描述表(上下文)；
　　（3）装入下一执行线程的描述表(上下文)；
　　（4）若存在等待被执行的线程，则重复上述过程。

　　win32下的线程可能具有不同的优先级，优先级的范围为0～31，共32级，其中31表示最高优先级，优先级0为系统保留。它们可以分成两类，即实时优先级和可变优先级：

　　（1）实时优先级从16到31，是实时程序所用的高优先级线程，如许多监控类应用程序；
　　（2）可变优先级从1到15，绝大多数程序的优先级都在这个范围内。。win32调度器为了优化系统响应时间，在它们执行过程中可动态调整它们的优先级。

　　多线程确实给应用开发带来了许多好处，但并非任何情况下都要使用多线程，一定要根据应用程序的具体情况来综合考虑。一般来说，在以下情况下可以考虑使用多线程：

　　（1）应用程序中的各任务相对独立；
　　（2）某些任务耗时较多；
　　（3）各任务需要有不同的优先级。

　　另外，对于一些实时系统应用，应考虑多线程。win32核心对 　　win32核心对象包括进程、线程、文件、事件、信号量、互斥体和管道，核心对象可能有不只一个拥有者，甚至可以跨进程。有一组win32 api与核心对象息息相关：

　　（1）waitforsingleobject，用于等待对象的"激活"，其函数原型为：

dword waitforsingleobject(
　handle hhandle, // 等待对象的句柄
　dword dwmilliseconds // 等待毫秒数，infinite表示无限等待
);

　 　可以作为waitforsingleobject第一个参数的对象包括：change notification（变更通知）、console input（控制台标准输入）、event、job、memory resource notification、mutex、process、semaphore、thread和waitable timer。

　　如果等待的对象不可用，那么线程就会挂起，直到对象可用线程才会被唤醒。对不同的对象，waitforsingleobject表现为不同的含义。例如，使用 waitforsingleobject(hthread,…)可以判断一个线程是否结束；使用waitforsingleobject (hmutex,…)可以判断是否能够进入临界区；而waitforsingleobject (hprocess,… )则表现为等待一个进程的结束。

　　与waitforsingleobject对应还有一个waitformultipleobjects函数，可以用于等待多个对象，其原型为：

dword waitformultipleobjects(dword ncount,const handle* phandles,bool bwaitall,dword dwmilliseconds);

　　（2）closehandle，用于关闭对象，其函数原型为：

bool closehandle(handle hobject);

　　如果函数执行成功，则返回true；否则返回false，我们可以通过getlasterror函数进一步可以获得错误原因。

　　c运行时库

　　在vc++6.0中，有两种多线程编程方法：一是使用c运行时库及win32 api函数，另一种方法是使用mfc，mfc对多线程开发有强大的支持。
标准c运行时库是1970年问世的，当时还没有多线程的概念。因此，c运行时库早期的设计者们不可能考虑到让其支持多线程应用程序。
visual c++提供了两种版本的c运行时库，一个版本供单线程应用程序调用，另一个版本供多线程应用程序调用。多线程运行时库与单线程运行时库有两个重大差别：

　　（1）类似errno（errno 是记录系统的最后一次错误代码）的全局变量，每个线程单独设置一个；
这样从每个线程中可以获取正确的错误信息。
　　（2）多线程库中的数据结构以同步机制加以保护。

　　这样可以避免访问时候的冲突。

　　visual c++提供的多线程运行时库又分为静态链接库和动态链接库两类，而每一类运行时库又可再分为debug版和release版，因此visual c++共提供了6个运行时库。如下表：

c运行时库	库文件
single thread(static link)	libc.lib
debug single thread(static link)	libcd.lib
multithread(static link)	libcmt.lib
debug multithread(static link)	libcmtd.lib
multithread(dynamic link)	msvert.lib
debug multithread(dynamic link)	msvertd.lib

　　如果不使用vc多线程c运行时库来生成多线程程序，必须执行下列操作：

　　（1）使用标准 c 库（基于单线程）并且只允许可重入函数集进行库调用；

　　（2）使用 win32 api 线程管理函数，如 createthread；

　　（3）通过使用 win32 服务（如信号量和 entercriticalsection 及 leavecriticalsection 函数），为不可重入的函数提供自己的同步。

　　如果使用标准 c 库而调用vc运行时库函数，则在程序的link阶段会提示如下错误：

error lnk2001: unresolved external symbol __endthreadex
error lnk2001: unresolved external symbol __beginthreadex

二．深入浅出win32多线程程序设计之线程控制

 

win32线程控制主要实现线程的创建、终止、挂起和恢复等操作，这些操作都依赖于win32提供的一组api和具体编译器的c运行时库函数。

　　1.线程函数

　　在启动一个线程之前，必须为线程编写一个全局的线程函数，这个线程函数接受一个32位的lpvoid（没有类型的指针）作为参数，返回一个uint，线程函数的结构为：

uint threadfunction(lpvoid pparam)
{
　//线程处理代码
　return0;
}

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

while(1)
{
　waitforsingleobject(…,…);//或waitformultipleobjects(…)
　//do something
}

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

#include "windows.h"
#include <process.h>
class exampletask 
{ 
　public: 
　　void taskmain(lpvoid param); 
　　void starttask(); 
}; 
void exampletask::taskmain(lpvoid param) 
{} 

void exampletask::starttask() 
{ 
　_beginthread(taskmain,0,null);
} 

int main(int argc, char* argv[])
{
　exampletask realtimetask;
　realtimetask.starttask();
　return 0;
}

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

error c2664: '_beginthread' : cannot convert parameter 1 from 'void (void *)' to 'void (__cdecl *)(void *)'
none of the functions with this name in scope match the target type

　　再看下列程序：

#include "windows.h"
#include <process.h>
class exampletask 
{ 
　public: 
　　void taskmain(lpvoid param); 
}; 

void exampletask::taskmain(lpvoid param) 
{} 

int main(int argc, char* argv[])
{
　exampletask realtimetask;
　_beginthread(exampletask::taskmain,0,null);
　return 0;
}

　　程序编译时会出错：

error c2664: '_beginthread' : cannot convert parameter 1 from 'void (void *)' to 'void (__cdecl *)(void *)'
none of the functions with this name in scope match the target type

　　如果一定要以类成员函数作为线程函数，通常有如下解决方案：

　　（1）将该成员函数声明为static类型，去掉this指针；

　　我们将上述二个程序改变为：

#include "windows.h"
#include <process.h>
class exampletask 
{ 
　public: 
　　void static taskmain(lpvoid param); 
　　void starttask(); 
}; 

void exampletask::taskmain(lpvoid param) 
{} 

void exampletask::starttask() 
{ 
　_beginthread(taskmain,0,null);
} 

int main(int argc, char* argv[])
{
　exampletask realtimetask;
　realtimetask.starttask();
　return 0;
}
和
#include "windows.h"
#include <process.h>
class exampletask 
{ 
　public: 
　　void static taskmain(lpvoid param); 
}; 

void exampletask::taskmain(lpvoid param) 
{} 

int main(int argc, char* argv[])
{
　_beginthread(exampletask::taskmain,0,null);
　return 0;
}

　　均编译通过。

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

　　我们将程序修改为：

#include "windows.h"
#include <process.h>
class exampletask 
{ 
　public: 
　　friend void taskmain(lpvoid param); 
　　void starttask(); 
}; 

void taskmain(lpvoid param) 
{ 
　exampletask * ptaskmain = (exampletask *) param; 
　//通过ptaskmain指针引用 
} 

void exampletask::starttask() 
{ 
　_beginthread(taskmain,0,this);
}
int main(int argc, char* argv[])
{
　exampletask realtimetask;
　realtimetask.starttask();
　return 0;
}

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

2.创建线程

　　进程的主线程由操作系统自动生成，win32提供了createthread api来完成用户线程的创建，该api的原型为：

handle createthread(
　lpsecurity_attributes lpthreadattributes,//pointer to a security_attributes structure
　size_t dwstacksize, //initial size of the stack, in bytes.
　lpthread_start_routine lpstartaddress,
　lpvoid lpparameter, //pointer to a variable to be passed to the thread
　dword dwcreationflags, //flags that control the creation of the thread
　lpdword lpthreadid //pointer to a variable that receives the thread identifier
);

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

uintptr_t _beginthread( 
　void( __cdecl *start_address )( void * ), //start address of routine that begins execution of new thread
　unsigned stack_size, //stack size for new thread or 0.
　void *arglist //argument list to be passed to new thread or null
);
uintptr_t _beginthreadex( 
　void *security,//pointer to a security_attributes structure
　unsigned stack_size,
　unsigned ( __stdcall *start_address )( void * ),
　void *arglist,
　unsigned initflag,//initial state of new thread (0 for running or create_suspended for suspended); 
　unsigned *thrdaddr 
);

　　_beginthread函数与win32 api 中的createthread函数类似，但有如下差异： 

　　（1）通过_beginthread函数我们可以利用其参数列表arglist将多个参数传递到线程； 

　　（2）_beginthread 函数初始化某些 c 运行时库变量，在线程中若需要使用 c 运行时库。 

　　3.终止线程

　　线程的终止有如下四种方式：

　　（1）线程函数返回；
　　（2）线程自身调用exitthread 函数即终止自己，其原型为：

void exitthread(uint fuexitcode );

　　它将参数fuexitcode设置为线程的退出码。

　　注意：如果使用c/c++编写代码，我们应该使用c/c++运行时库函数_endthread (_endthreadex)终止线程，决不能使用exitthread！
_endthread 函数对于线程内的条件终止很有用。例如，专门用于通信处理的线程若无法获取对通信端口的控制，则会退出。

　　（3）同一进程或其他进程的线程调用terminatethread函数，其原型为：

bool terminatethread(handle hthread,dword dwexitcode);

　　该函数用来结束由hthread参数指定的线程，并把dwexitcode设成该线程的退出码。当某个线程不再响应时，我们可以用其他线程调用该函数来终止这个不响应的线程。

　　（4）包含线程的进程终止。

　　最好使用第1种方式终止线程，第2~4种方式都不宜采用。

　　4.挂起与恢复线程

　　当我们创建线程的时候，如果给其传入create_suspended标志，则该线程创建后被挂起，我们应使用resumethread恢复它：

dword resumethread(handle hthread);

　　如果resumethread函数运行成功，它将返回线程的前一个暂停计数，否则返回0x ffffffff。

　　对于没有被挂起的线程，程序员可以调用suspendthread函数强行挂起之：

dword suspendthread(handle hthread);

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

5.设置线程优先级

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

bool setthreadpriority(handle hthread, int npriority);

　　其中参数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。

 

     6.睡眠

void sleep(dword dwmilliseconds);

　　该函数可使线程暂停自己的运行，直到dwmilliseconds毫秒过去为止。它告诉系统，自身不想在某个时间段内被调度。

　　7.其它重要api

　　获得线程优先级

　　一个线程被创建时，就会有一个默认的优先级，但是有时要动态地改变一个线程的优先级，有时需获得一个线程的优先级。

int getthreadpriority (handle hthread);

　　如果函数执行发生错误，会返回thread_priority_error_return标志。如果函数成功地执行，会返回优先级标志。

　　获得线程退出码

bool winapi getexitcodethread(
　handle hthread,
　lpdword lpexitcode
);

　　如果执行成功，getexitcodethread返回true，退出码被lpexitcode指向内存记录；否则返回false，我们可通过getlasterror()获知错误原因。如果线程尚未结束，lpexitcode带回来的将是still_alive。

 

获得/设置线程上下文

bool winapi getthreadcontext(
　handle hthread,
　lpcontext lpcontext
);
bool winapi setthreadcontext(
　handle hthread,
　const context *lpcontext
);

　 　由于getthreadcontext和setthreadcontext可以操作cpu内部的寄存器，因此在一些高级技巧的编程中有一定应用。譬如， 调试器可利用getthreadcontext挂起被调试线程获取其上下文，并设置上下文中的标志寄存器中的陷阱标志位，最后通过 setthreadcontext使设置生效来进行单步调试。

　　8.实例

　　以下程序使用createthread创建两个线程，在这两个线程中sleep一段时间，主线程通过getexitcodethread来判断两个线程是否结束运行：

#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;

　hthrd1 = createthread(null, 0, threadfunc, (lpvoid)1, 0, &threadid );
　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.
　for (;;)
　{
　　printf("press any key to exit..\n");
　　getch();

　　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);
　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;
}

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

#define win32_lean_and_mean
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

dword winapi threadfunc(lpvoid);

int main()
{
　handle hthrd;
　dword threadid;
　int i;

　for (i = 0; i < 5; i++)
　{
　　hthrd = createthread(null, 0, threadfunc, (lpvoid)i, 0, &threadid);
　　if (hthrd)
　　{
　　　printf("thread launched %d\n", i);
　　　closehandle(hthrd);
　　}
　}
　// wait for the threads to complete.
　sleep(2000);

　return exit_success;
}

dword winapi threadfunc(lpvoid n)
{
　int i;
　for (i = 0; i < 10; i++)
　　printf("%d%d%d%d%d%d%d%d\n", n, n, n, n, n, n, n, n);
　return 0;
}

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

        如果我们使用标准c库函数而不是多线程版的运行时库，则程序可能输出"3333444444"这样的结果，而使用多线程运行时库后，则可避免这一问题。

　　下列程序在主线程中创建一个secondthread，在secondthread线程中通过自增对counter计数到1000000，主线程一直等待其结束：

#include <win32.h>
#include <stdio.h>
#include <process.h>

unsigned counter;
unsigned __stdcall secondthreadfunc(void *parguments)
{
　printf("in second thread...\n");

　while (counter < 1000000)
　　counter++;

　_endthreadex(0);
　return 0;
}

int main()
{
　handle hthread;
　unsigned threadid;

　printf("creating second thread...\n");

　// create the second thread.
　hthread = (handle)_beginthreadex(null, 0, &secondthreadfunc, null, 0, &threadid);

　// wait until second thread terminates 
　waitforsingleobject(hthread, infinite);
　printf("counter should be 1000000; it is-> %d\n", counter);
　// destroy the thread object.
　closehandle(hthread);
}