windows 线程 在windows中进程只是一个容器，用于装载系统资源，它并不执行代码，它是系统资源分配的最小单元，而在进程中执行代码的是线程，线程是轻量级的进程，是代码执行的最小单位。从系统的内核角度看，进程是一个内核对象，内核用这个对象来存储一些关于线程的信息，比如当前线程环境等等，从编程的角度看，线程就是一堆寄存器状态以及线程栈的一个结构体对象，本质上可以理解为一个函数调用，一般线程有一个代码的起始地址，系统需要执行线程，只需要将寄存器EIP指向这个代码的地址，那么CPU接下来就会自动的去执行这个线程，线程切换时也是修改EIP的值，那么CPU就回去执行另外的代码了。什么时候不用多线程？一般我们都讨论什么时候需要使用多线程，很多人认为只要计算任务能拆分成多个不想关的部分，就可以使用多线程来提升效率，但是需要知道的是，线程是很耗费资源的，同时CPU在线程之间切换也会消耗大量的时间，所以在使用上并不是多线程就是好的，需要慎重使用，在下列情况下不应该使用多线程：当一个计算任务是严重串行化的，也就是一个计算步骤严重依赖上一个计算步骤的时候。但是如果是针对不同的初始参数可以得到不同的结果那么可以考虑用多线程的方式，将每个传入参数当作一个线程，一次计算出多组数据。当多个任务有严格的先后逻辑关系的时候，这种情况下利用多线程需要额外考虑线程之间执行先后顺序的问题，实际上可能它的效率与普通的单线程程序差不多，它还需要额外考虑并发控制，这将得不偿失当一个服务器需要处理多个客户端连接的时候，优先考虑的是使用线程池，而不是简单的使用多线程，为每个客户端连接创建一个线程，这样会严重浪费资源，而且线程过的，CPU在进程调度时需要花大量的时间来执行轮询算法，会降低效率。主线程进程的入口函数就是主线程的入口函数，一般主线程推出进程退出（这是由于VC++中在主线程结束时会隐含的调用ExitProcess）线程入口地址在windows中需要为线程指定一个执行代码的开始地址，这个在VC++中体现为需要为每个进程制定一个函数指针，并制定一个void* 型的指针类型的参数。当CPU执行这个线程时会将寄存器环境改为这个线程指定的环境，然后执行代码（具体就是前面所说的更改EIP的值）创建线程在windows中创建线程所使用的API是CreateThread，这个函数的原型如下:HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpsa, DWORD cbStack, LPTHREAD_START_ROUTINE lpStartAddr, LPVOID lpvThreadParam, DWORD fdwCreate, LPDWORD lpIDThread );第一个参数是线程对象的安全描述符第二个参数是线程栈的大小，每个线程都有一个栈环境用来存储局部变量，以及调用函数，这个值可以给0，这个时候系统会根据线程中调用函数情况动态的增长，但是如果需要很大的线程栈，比如要进行深层的递归，并且每个递归都有大量的局部变量和函数时，运行一段时间后，可能会出现没有足够大的地址空间再来增长线程栈，这个时候就会出现栈溢出的异常，为了解决这个问题，我们可以填入一个较大的值，以通知系统预留足够大的地址空间。第三个参数是线程的入口函数地址，这个是一个函数指针，函数的原型是DWORD ThreadProc( LPVOID lpParameter); 函数中就是线程将要执行的代码。第四个参数是函数中将要传入的参数，为了方便传入多个参数，一般将要使用的过个参数定义为一个结构体，将这个结构体指针传入，然后再函数中将指针转化为需要的结构体指针，这样就可以使用多个参数。第五个参数是创建标志，默认一般传入0，但表示线程一被创建马上执行，如果传入CREATE_SUSPENDED,则表示线程先创建不执行，需要使用函数ResumeThread唤醒线程，另外在XP以上的系统中可以使用STACK_SIZE_PARAM_IS_A_RESERVATION结合上面的第二个参数，表示当前并不需要这么内存，只是先保留当前的虚拟地址空间，在需要时有程序员手动提交物理页面。如果没有指定那么回默认提交物理页面。第六个参数会返回一个线程的ID。下面是一个创建线程的例子:typedef struct tag_THREAD_PARAM { int nThreadNo; int nValue; }THREAD_PARAM, *LPTHREAN_PARAM; int _tmain(int argc, TCHAR *argv[]) { LPTHREAN_PARAM lpValues = (LPTHREAN_PARAM)HeapAlloc(GetProcessHeap(), 0, 10 * sizeof(THREAD_PARAM)); for (int i =0; i < 10; i++) { lpValues[i].nThreadNo = i; lpValues[i].nValue = i + 100; } HANDLE hHandle[10] = {NULL}; for(int i = 0; i < 10; i++) { hHandle[i] = CreateThread(NULL, 0, ThreadProc, &lpValues[i], 0, NULL); if (NULL == hHandle[i]) { return 0; } } WaitForMultipleObjects(10, hHandle, TRUE, INFINITE); return 0; } DWORD WINAPI ThreadProc(LPVOID lpParam) { LPTHREAN_PARAM pThreadValues = (LPTHREAN_PARAM)lpParam; printf("%d, values = %d\n", pThreadValues->nThreadNo, pThreadValues->nValue); return 0; }上述代码中我们将两个整型数据定义为了一个结构体，并在创建线程中，将这个结构体地址作为参数传入，这样在线程中就可以使用这样的两个参数了。线程退出当满足下列条件之一时线程就会退出调用ExitThread线程函数返回调用ExitProcess用线程句柄调用TerminateThread用进程句柄调用TerminateProcess当线程终止时，线程对象的状态会变为有信号，线程状态码会由STILL_ACTIVE改为线程的退出码，可以用GetExitThreadCode得到推出码，然后根据推出码是否为STILL_ACTIVE判断线程是否在运行线程栈溢出的恢复使用C++时由于下标溢出而造成的栈溢出将无法恢复。当栈溢出时会抛出EXCEPTION_STACK_OVERFLOW的结构化异常，之后使用_resetstkflow函数可以恢复栈环境，这个函数只能在_except的语句块中使用。调用 SetThreadStackGuarantee函数可以保证当栈溢出时有足够的栈空间能使用结构话异常处理，SEH在底层仍然是使用栈进行异常的抛出和处理的，所以如果不保证预留一定的栈空间，可能在最后使用不了SEH。下面是一个使用的例子:void ArrayErr(); void Stackflow(); DWORD _exception_stack_overflow(DWORD dwErrorCcode); int g_nCnt = 0; int _tmain(int argc, TCHAR *argv[]) { for (int i = 0; i < 10; i++) { __try { /* ArrayErr();*/ Stackflow(); } __except(_exception_stack_overflow(GetExceptionCode())) { int nResult = _resetstkoflw(); if (!nResult) { printf("处理失败\n"); break; }else { printf("处理成功\n"); } } } return 0; } void ArrayErr() { int array[] = {1, 2}; array[10000] = 10; } void Stackflow() { g_nCnt++; int array[1024] = {0}; Stackflow(); } DWORD _exception_stack_overflow(DWORD dwErrorCcode) { if (EXCEPTION_STACK_OVERFLOW == dwErrorCcode) { return EXCEPTION_EXECUTE_HANDLER; }else { return EXCEPTION_CONTINUE_SEARCH; } }在上述的例子中定义两个会引起异常的函数，一个是下标越界，一个是深度的递归，两种情况都会引起栈溢出，但是下标越界是不可恢复的，所以这个异常不能被处理，在异常处理中我们使用函数_resetstkoflw来恢复栈，使得程序可以继续运行下去。线程本地存储当线程需要访问一个共同的全局变量，并且某个线程对这个变量的修改不会影响到其他的进程的时候可以给予每个线程一份拷贝，每个线程访问变量在它自己中的拷贝，而不用去争抢这一个全局变量，有时候我们可能会想出用数组的方式来存储这每份拷贝，每个线程访问数组中的固定元素，但是当线程是动态创建和销毁也就是线程数量动态变化时，维护这个数组将会非常困难，这个时候可以使用线程本地存储技术（TLS），它的基本思想是在访问全局变量时给每个线程一个实例，各个线程访问这个实例而不用去争抢一个全局变量。就好像系统为我们维护了一个动态数组，让每个线程拥有这个数组中的固定元素。使用TLS有两种方法关键字法和API法。关键字法： 使用关键字__declspec(thread)修饰一个变量，这样就可以为每个访问它的线程创建一份拷贝。动态API法，TlsAlloc为每个全局变量分配一个TLS索引, TlsSetValue为某个索引设置一个值，TlsGetValue获取某个索引的值TlsFree释放这个索引两中方式各有优缺点，第一种方式使用简单，但是仅仅局限于VC++,第二中方式使用相对复杂但是可以跨语言只要能使用windowsAPI就可以使用这种方式下面分别展示了使用这两种方式的例子:DWORD _declspec(thread) g_dwCurrThreadID = 0; DWORD WINAPI ThreadProc(LPVOID lpParam); int main() { g_dwCurrThreadID = GetCurrentThreadId(); HANDLE hThread[10] = {NULL}; for (int i = 0; i < 10; i++) { hThread[i] = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL); } printf("Main Thread id = %x, g_dwCurrThreadID = %x, the address g_dwCurrThreadID = %08x\n", GetCurrentThreadId(), g_dwCurrThreadID, &g_dwCurrThreadID); WaitForMultipleObjects(10, hThread, TRUE, INFINITE); for (int i = 0; i < 10; i++) { CloseHandle(hThread[i]); } return 0; } DWORD WINAPI ThreadProc(LPVOID lpParam) { g_dwCurrThreadID = GetCurrentThreadId(); Sleep(100); printf("the thread id = %x, g_dwCurrThreadID = %x, the address g_dwCurrThreadID = %08x\n", GetCurrentThreadId(), g_dwCurrThreadID, &g_dwCurrThreadID); return 0; }首先定义了一个TLS的变量，然后在线程中引用，在输出结果中发现，没个线程中的值和它的地址值都不一样，所以说使用的只是一份拷贝而已DWORD g_dwTLSIndex = 0; DWORD WINAPI ThreadProc(LPVOID lpParam); int main() { HANDLE hThread[10] = {NULL}; g_dwTLSIndex = TlsAlloc(); TlsSetValue(g_dwTLSIndex, (LPVOID)GetCurrentThreadId()); for (int i = 0; i < 10; i++) { hThread[i] = CreateThread(NULL, 0, ThreadProc, NULL, CREATE_SUSPENDED, NULL); ResumeThread(hThread[i]); } printf("Main Thread id = %x, g_dwCurrThreadID = %x\n", GetCurrentThreadId(), TlsGetValue(g_dwTLSIndex)); WaitForMultipleObjects(10, hThread, TRUE, INFINITE); for (int i = 0; i < 10; i++) { CloseHandle(hThread[i]); } TlsFree(g_dwTLSIndex); return 0; } DWORD WINAPI ThreadProc(LPVOID lpParam) { TlsSetValue(g_dwTLSIndex, (LPVOID)GetCurrentThreadId()); printf("the thread id = %x, g_dwCurrThreadID = %x\n", GetCurrentThreadId(), TlsGetValue(g_dwTLSIndex)); return 0; } 上述使用中，在主线程中申请和释放一个TLS变量，在每个进程中仍然是使用这个变量，输出的结果也是每个变量都不同。线程的挂起和恢复用函数SuspendThread和ResumeThread控制线程的暂停和恢复，一个暂停的线程无法用ResumeThread来唤醒自身，除非有其他线程调用ResumeThread来唤醒。暂停的线程总是立即被暂停，而不管它执行到了哪个指令。需要注意的是，线程这个内核对象中有一个暂停计数器，每当调用一个SuspendThread这个计数器会加一，而每当调用一次ResumeThread计数器会减一，只有当计数器为0时线程才会立即启动，所以可能会出现这样的情况，调用了ResumeThread之后线程并没有立即启动，这个是正常现象。另外可以使用Sleep函数使线程休眠一段时间后再启动，这个填入的时间只是一个参考值，并不是填入多少，就让线程暂停多久，比如说我们填入10ms，这个时候当线程真正陷入到休眠状态时CPU可能执行其他线程去了，如果没有特殊情况，CPU会一直执行到这个线程的时间片结束。然后运行调度程序，调度下一个线程，所以说线程休眠的时间理论上最少也有20ms，通常会比我们设置的时间长。在创建线程的时候可以使用CREATE_SUSPEND标志来明确表示以暂停的方式创建一个线程，如果不用这个方式，那么新创建线程的行为将难以掌握，有可能在CreateThread函数返回之后，线程就开始执行了，也有可能在返回前执行，所以推荐使用这个标志，创建完成后，进行想干的初始化操作，并在必要的时候调用ResumeThread启动它。线程的寄存器状态线程环境也就是线程在运行中，一大堆相关寄存器的值，这些值Windows维护在CONTEXT这个结构体中，在获取时可以通过设置结构体中成员的ContextFlag的值来表示我们需要获取哪些寄存器的值，一般填入CONTEXT_ALL或者CONTEXT_FULL获取所有寄存器的值，用SetThreadContext设置线程寄存器的值，用GetThreadContext获取线程的寄存器环境。需要注意的时，SetThreadContext只能用来修改通用寄存器的值，而像DS, CS这样的段寄存器是收到系统保护的，这些函数是处于RING3层，并不能进入到内核态。线程调度的优先级windows是抢占式多任务的，各个线程是抢占式的获取CPU，一般遵循先到先执行的顺序，windows中的带调度线程是存储在线程队列中的，但是这个队列并不是真正意义上的队列，这个队列是允许插队的，比如当用户点击了某个窗口，那么系统为了响应用户操作，系统会激活窗口并调整队列的顺序，将于窗口相关的线程排到较前的位置，这个插队时通过提高线程的优先级的方式实现的。我们在程序中可以使用SetThreadPriority调整线程的优先级。但是在程序中不要依赖这个值来判断线程的执行顺序，这个值对于系统来说只是一个参考值，当我们的线程进入到队列中时，系统会动态的调整它的优先级，如果某个进程由于优先级的问题长时间没有运行，系统可能会提高它的优先级，而有的线程由于优先级过高，已经执行了多次，系统可能会降低它的优先级。一来可以快速响应用户程序，二来可以防止某些恶意程序抢占式的使用CPU资源。线程的亲缘性线程的亲缘性与进程的相似，但是线程的亲缘性只能在进程亲缘性的子集之上，比如进程的亲缘性被设置在0 2 3 8这几个CPU上，线程就只能在这几个CPU上运行即使设置亲缘性为7，系统也不会将线程加载到这个7号CPU上运行。调用函数SetThreadAffinityMask可以设置亲缘性，使所有线程都在不同的CPU上运行，已达到真正的并发执行。下面是一个使用亲缘性的例子://设置CPU的位掩码 #define SETCPUMASK(i) (1<<(i)) DWORD WINAPI ThreadProc(LPVOID lpParam); #define FOREVER for(;;); int _tmain() { SYSTEM_INFO si = {0}; GetSystemInfo(&si); DWORD dwCPUCnt = si.dwNumberOfProcessors; for (int i = 0; i < dwCPUCnt; i++) { HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, CREATE_SUSPENDED, NULL); SetThreadAffinityMask(hThread, SETCPUMASK(i)); ResumeThread(hThread); printf("启动线程%x成功", GetCurrentThreadId()); system("PAUSE"); } //线程创建成功，并绑定到各个CPU上，理论上CPU的利用率能达到100%,在任务管理器上查看性能可以看到CPU的利用率 return 0; } DWORD WINAPI ThreadProc(LPVOID lpParam) { //死循环 FOREVER }上述程序首先判断了CPU核数，然后有几个CPU就创建几个线程，通过亲缘性设置为每个CPU绑定一个线程，在线程中我们什么都不做，只是一个死循环，主要是为了耗干CPU资源，这样通过查看资源管理器中的CPU使用情况发现CPU的使用率达到了100%，但是系统却没有一丝卡顿，这也说明Windows还是比较智能的，并没有让用户进程占据所有资源。线程可警告状态与异步函数在程序中可以通过一些方法使线程暂停，如使用SleepEx,Wait族的函数（是以Wait开始并且以Ex结尾的函数）可以使线程进入一种可警告状态，这种状态本质上是暂停当前线程，保存当前线程环境，并用这个环境加载并执行新的函数，当这个函数执行完成后，再恢复线程环境，继续执行线程接下来的代码。这些函数被称为异步函数。也就是说这些函数是借用当前的线程环境来作为自生的环境执行里面的代码。这样就类似于创建了一个轻量级的线程，它与线程的区别就是没有自身的环境状态，而是使用其他线程的环境状态，并且也不用进入到线程队列，供调度程序调度。这些异步函数有自己的队列称为异步函数队列，当线程调用这些暂停或者等待的函数时，进入休眠状态，系统会保存当前线程环境，并从异步函数队列中加载异步函数，利用当前的线程环境继续运行，等到休眠时间到达后系统恢复之前保存的环境，继续执行线程的代码。在使用时需要注意的是这些异步函数不要进行复杂的算法或者进程长时间的I/O操作，否则当线程休眠时间达到，而异步函数却未执行完，这样会造成一定的错误。默认线程是不具有异步函数队列，可以利用函数QueueUserAPC将一个异步函数加入到队列中，然后利用上述所说的函数让线程进入假休眠状态，这样就会自动调用异步函数，下面是这样的一个例子：VOID CALLBACK APCProc(ULONG_PTR dwParam) { printf("%d Call APC Function!\n", dwParam); } int _tmain(int argc, TCHAR *argv[]) { for (int i = 0 ; i < 100; i++) { QueueUserAPC(APCProc, GetCurrentThread(), i); } //如果参数改为FALSE，或者注释掉这个函数，那么将不会调用这个APC函数 SleepEx(10000, true); return 0; }上述代码中，我们在主线程中插入100个异步函数，虽然它们执行的都是同样的操作，然后让主线程休眠，SleepEx函数的第二个参数表示是否调用异步函数，如果填入FALSE，或者调用Sleep函数则不会调用异步函数。线程的消息队列线程默认是不具有消息队列的，同时也没有创建消息队列的函数，一般只需要调用与消息相关的函数，系统就会默认创建消息队列。调用PostThreadMessage可以向指定的线程发送消息到消息队列，调用PostThread可以向当前线程发送消息到消息队列，在编写带有消息循环的线程时可能由于线程有耗时的初始化操作，发送到线程的消息可能还没有被接受就丢掉了，但是如果在进行初始化时调用消息函数，让其创建一个消息队列，可以解决这问题，下面是一段例子代码:DWORD WINAPI ThreadProc(LPVOID lpParam) { MSG msg = {0}; /*利用消息相关的函数让线程创建消息队列,如果不创建，可能所有消息都不能收到 这个时候子线程会陷入死循环，主线程会一直等待子进程*/ PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE); //模拟进行耗时的初始化操作 for (int i = 0; i < 10000000; i++); while (GetMessage(&msg, NULL, 0, 0)) { printf("receive msg %d\n", msg.message); } printf("子线程退出\n"); return 0; } int _tmain(int argc, TCHAR *argv[]) { DWORD dwThreadID = 0; HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadID); //让主线程休眠一段时间，一遍子线程能创建消息队列 Sleep(10); //发送消息 PostThreadMessage(dwThreadID, 0x0001, 0, 0); PostThreadMessage(dwThreadID, 0x0002, 0, 0); PostThreadMessage(dwThreadID, 0x0003, 0, 0); PostThreadMessage(dwThreadID, WM_QUIT, 0, 0); //休眠一段时间让子进程能够执行完成 WaitForSingleObject(hThread, INFINITE); return 0; }线程执行时间在一些性能分析工具中可能需要使用得到具体执行某一算法的函数的执行时间，一般调用GetTickCount计算调用前时间然后在算法函数调用完成后再次调用GetTickCount再次得到时间，这两个时间详相减则得到具体算法的时间，一般这种算法没有问题，但是需要考虑的时，如果在多任务环境下，该线程的时间片到达，CPU切换到其他线程，该线程没有运行但是时间却在增加，所以这种方式得到的结果并不准确，替代的方案是使用GetThreadTimes。这个函数可以精确到100ns，并且得出系统执行该线程的具体时间，下面是函数的原型：BOOL GetThreadTimes ( HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );这个函数后面几个输出参数分别是线程的创建时间，线程的推出时间，执行内核的时间以及执行用户代码的时间。下面演示了他的具体用法：DWORD WINAPI ThreadProc(LPVOID lpParam) { DWORD dwStart = GetTickCount(); HANDLE hWait = (HANDLE)lpParam; //假设这是一个复杂的算法 while (TRUE) { if (WAIT_OBJECT_0 == WaitForSingleObject(hWait, 0)) { break; } } //模拟CPU调度其他线程 Sleep(3000); DWORD dwEnd = GetTickCount(); printf("子线程即将结束，当前执行算法所用的时间为:%d\n", dwEnd - dwStart); return 0; } int _tmain(int argc, TCHAR *argv[]) { HANDLE hWait = CreateEvent(NULL, TRUE, FALSE, NULL); DWORD dwCPUNum = 0; SYSTEM_INFO si = {0}; GetSystemInfo(&si); dwCPUNum = si.dwNumberOfProcessors; HANDLE* phThread = (HANDLE*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwCPUNum * sizeof(HANDLE)); DWORD dwExitCode = 0; for (int i = 0; i < dwCPUNum; i++) { phThread[i] = CreateThread(NULL, 0, ThreadProc, hWait, CREATE_SUSPENDED, NULL); SetThreadAffinityMask(phThread[i], 1 << i); ResumeThread(phThread[i]); } _tsystem(_T("PAUSE")); //通知所有线程停止 SetEvent(hWait); FILETIME tmCreate = {0}; FILETIME tmExit = {0}; FILETIME tmKernel = {0}; FILETIME tmUser = {0}; SYSTEMTIME sysTm = {0}; ULARGE_INTEGER bigTmp1 = {0}; ULARGE_INTEGER bigTmp2 = {0}; for (int i = 0; i < dwCPUNum; i++) { GetExitCodeThread(phThread[i], &dwExitCode); printf("线程[H:0x%08X]退出，退出码:%u，以下为时间统计信息:\n", phThread[i], dwExitCode); GetThreadTimes(phThread[i], &tmCreate, &tmExit, &tmKernel, &tmUser); //得到创建时间 FileTimeToLocalFileTime(&tmCreate, &tmCreate); FileTimeToSystemTime(&tmCreate, &sysTm); printf("\t创建时间:%2u:%02u:%02u.%04u\n", sysTm.wHour, sysTm.wMinute, sysTm.wSecond, sysTm.wMilliseconds); //得到退出时间 FileTimeToLocalFileTime(&tmExit, &tmExit); FileTimeToSystemTime(&tmExit, &sysTm); printf("\t退出时间:%2u:%02u:%02u.%04u\n", sysTm.wHour, sysTm.wMinute, sysTm.wSecond, sysTm.wMilliseconds); //得到执行内核代码的时间 FileTimeToLocalFileTime(&tmKernel, &tmKernel); FileTimeToSystemTime(&tmKernel, &sysTm); printf("\t退出时间:%2u:%02u:%02u.%04u\n", sysTm.wHour, sysTm.wMinute, sysTm.wSecond, sysTm.wMilliseconds); //得到执行用户代码的时间 FileTimeToLocalFileTime(&tmUser, &tmUser); FileTimeToSystemTime(&tmUser, &sysTm); printf("\t退出时间:%2u:%02u:%02u.%04u\n", sysTm.wHour, sysTm.wMinute, sysTm.wSecond, sysTm.wMilliseconds); //线程开始时间 bigTmp1.HighPart = tmCreate.dwHighDateTime; bigTmp1.LowPart = tmCreate.dwLowDateTime; bigTmp2.HighPart = tmExit.dwHighDateTime; bigTmp2.LowPart = tmExit.dwLowDateTime; //函数GetThreadTimes返回的时间单位是100ns，是微妙的10000倍 printf("\t间隔时间(线程存活周期):%I64dms\n", (bigTmp2.QuadPart - bigTmp1.QuadPart) / 10000); //内核执行时间 bigTmp1.HighPart = tmKernel.dwHighDateTime; bigTmp1.LowPart = tmKernel.dwLowDateTime; printf("\t内核模式(RING0)耗时:%I64dms!\n", bigTmp1.QuadPart / 10000); //执行用户程序的时间 bigTmp2.HighPart = tmUser.dwHighDateTime; bigTmp2.LowPart = tmUser.dwLowDateTime; printf("\t内核模式(RING0)耗时:%I64dms!\n", bigTmp2.QuadPart / 10000); //实际占用总时间(用户代码时间 + 内核代码执行时间) printf("\t内核模式(RING0)耗时:%I64dms!\n", (bigTmp1.QuadPart + bigTmp2.QuadPart)/ 10000); CloseHandle(phThread[i]); system("PAUSE"); } //释放资源 CloseHandle(hWait); HeapFree(GetProcessHeap(), 0, phThread); return 0; }以类成员函数的方式封装线程类一般在如果要将线程函数封装到C++类中时一般采用的是静态成员的方式，因为C++中默认总会多传入一个参数this，而CreateThread需要传入的函数指针并不包含this，所以为了解决这个问题，一般传入一个静态函数的指针，但是静态函数不能定义为虚函数，也就是不能在派生类中重写它，所以在这介绍一种新的封装方式，将其封装为成员函数，并且允许被派生类重写。它的基本思想：利用函数指针的强制转化让类成员函数指针强制转化为CreateThread需要的类型，这样在真正调用函数我们给定的函数地址时就不会传入this指针，但是为了使用类成员函数又需要这个指针，所以我们将this 指针的值变为参数，通过CreateThread的进行传递，这样就模拟了C++类成员函数的调用，下面是实现的部分代码://申明了这样一个线程的入口地址函数 DWORD WINAPI ThreadProc(LPVOID lpParam); //创建线程的代码 DWORD CMyThread::CreateThread(LPSECURITY_ATTRIBUTES lpsa, DWORD cbStack, DWORD fdwCreate) { typedef DWORD (WINAPI *LPTHREAD_START_ADDRESS)(LPVOID); typedef DWORD (WINAPI CMyThread::*PCLASS_PROC)(LPVOID); PCLASS_PROC pThreadProc = &CMyThread::ThreadProc; m_hThread = ::CreateThread(lpsa, cbStack, *(LPTHREAD_START_ADDRESS*)(&pThreadProc), this, fdwCreate, &m_dwThreadID); return (NULL != m_hThread) ? -1 : 0; }完整的代码 请戳这里下载

windows 多任务与进程 多任务，进程与线程的简单说明多任务的本质就是并行计算，它能够利用至少2处理器相互协调，同时计算同一个任务的不同部分，从而提高求解速度，或者求解单机无法求解的大规模问题。以前的分布式计算正是利用这点，将大规模问题分解为几个互不不相关的问题，将这些计算问题交给局域网中的其他机器计算完成，然后再汇总到某台机器上，显示结果，这样就充分利用局域网中的计算机资源。相对的，处理完一步接着再处理另外一步，将这样的传统计算模式称为串行计算。在提高处理器的相关性能主要有两种方式，一种是提高单个处理器处理数据的速度，这个主要表现在CPU主频的调高上，而当前硬件总有一个上限，以后再很难突破，所以现在的CPU主要采用的是调高CPU的核数，这样CPU的每个处理器都处理一定的数据，总体上也能带来性能的提升。在某些单核CPU上Windows虽然也提供了多任务，但是这个多任务是分时多任务，也就是每个任务只在CPU中执行一个固定的时间片，然后再切换到另一个任务，由于每个任务的时间片很短，所以给人的感觉是在同一时间运行了多个任务。单核CPU由于需要来回的在对应的任务之间切换，需要事先保存当前任务的运行环境，然后通过轮循算法找到下一个运行的任务，再将CPU中寄存器环境改成新任务的环境，新任务运行到达一定时间，又需要重复上述的步骤，所以在单核CPU上使用多任务并不能带来性能的提升，反而会由在任务之间来回切换，浪费宝贵的资源，多任务真正使用场合是多核的CPU上。windows上多任务的载体是进程和线程，在windows中进程是不执行代码的，它只是一个载体，负责从操作系统内核中分配资源，比如每个进程都有4GB的独立的虚拟地址空间，有各自的内核对象句柄等等。线程是资源分配的最小单元，真正在使用这些资源的是线程。每个程序都至少有一个主线程。线程是可以被执行的最小的调度单位。进程的亲缘性进程或者线程只在某些CPU上被执行，而不是由系统随机分配到任何可用的CPU上，这个就是进程的亲缘性。例如某个CPU有8个处理器，可以通过进程的亲缘性设置让该进程的线程只在某两个处理器上运行，这样就不会像之前那样在8个CPU中的任意几个上运行。在windows上一般更倾向于优先考虑将线程安排在之前执行它的那个处理器上运行，因为之前的处理器的高速缓存中可能存有这个线程之前的执行环境，这样就提高的高速缓存的命中率，减少了从内存中取数据的次数能从一定程度上提高性能。需要注意的是，在拥有三级高速缓存的CPU上，这么做意义就不是很大了，因为三级缓存一般作为共享缓存，由所有处理器共享，如果之前在2号处理器上执行某个线程，在三级缓存上留下了它的运行时的数据，那么由于三级缓存是由所有处理器所共享的，这个时候即使将这个线程又分配到5号处理器上，也能访问这个公共存储区，所以再设置线程在固定的处理器上运行就显得有些鸡肋，这也是拥有三级缓存的CPU比二级缓存的CPU占优势的地方。但是如果CPU只具有二级缓存，通过设置亲缘性可以发挥高速缓存的优势，提高效率。亲缘性可以通过函数SetProcessAffinityMask设置。该函数的原型如下：BOOL WINAPI SetProcessAffinityMask( __in HANDLE hProcess, __in DWORD_PTR dwProcessAffinityMask );第一个参数是设置的进程的句柄，第二个参数是DWORD类型的指针，是一个32位的整数，每一位代表一个处理器的编号，当希望设置进程中的线程在此处理器上运行的话，将该位设置为1，否则为0。为了设置亲缘性，首先应该了解机器上CPU的情况，根据实际情况来妥善安排，获取CPU的详细信息可以通过函数GetLogicalProcessInformation来完成。该函数的原型如下：BOOL WINAPI GetLogicalProcessorInformation( __out PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, __in_out PDWORD ReturnLength );第一个参数是一个结构体的指针，第二个参数是需要缓冲区的大小，也就是说这个函数我们可以采用两次调用的方式来合理安排缓冲区的大小。结构体SYSTEM_LOGICAL_PROCESSOR_INFORMATION的定义如下： typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION { ULONG_PTR ProcessorMask; LOGICAL_PROCESSOR_RELATIONSHIP Relationship; union { struct { BYTE Flags; } ProcessorCore; struct { DWORD NodeNumber; }NumaNode; CACHE_DESCRIPTOR Cache; ULONGLONG Reserved[2]; }; } SYSTEM_LOGICAL_PROCESSOR_INFORMATION, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION;ProcessorMask是一个位掩码，每个位代表一个逻辑处理器，第二个参数是一个标志，表示该使用第三个共用体中的哪一个结构体，这三个分别表示核心处理器，NUMA节点，以及高速缓存的信息。下面是使用的一个例子代码：#include <windows.h> #include <tchar.h> #include <stdio.h> #include <locale.h> DWORD CountBits(ULONG_PTR uMask); typedef BOOL (WINAPI *CPUINFO)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnLength); int _tmain(int argc, TCHAR *argv[]) { _tsetlocale(LC_ALL, _T("chs")); CPUINFO pGetCpuInfo = (CPUINFO)GetProcAddress(GetModuleHandle(_T("kernel32")), "GetLogicalProcessorInformation"); if (NULL == pGetCpuInfo) { _tprintf(_T("系统不支持该函数,程序结束\n")); return 0; } PSYSTEM_LOGICAL_PROCESSOR_INFORMATION plpt = NULL; DWORD dwLength = 0; if (!pGetCpuInfo(plpt, &dwLength)) { if (ERROR_INSUFFICIENT_BUFFER == GetLastError()) { plpt = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwLength); }else { _tprintf(_T("函数调用失败\n")); return 0; } } if (!pGetCpuInfo(plpt, &dwLength)) { _tprintf(_T("函数调用失败\n")); return 0; } DWORD dwSize = dwLength / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pOffsite = plpt; DWORD dwCacheCnt = 0; DWORD dwCoreCnt = 0; DWORD dwPackageCnt = 0; DWORD dwNodeCnt = 0; for (int i = 0; i < dwSize; i++) { switch (pOffsite->Relationship) { case RelationCache: dwCacheCnt++; break; case RelationNumaNode: dwNodeCnt++; break; case RelationProcessorCore: { if (pOffsite->ProcessorCore.Flags) { dwCoreCnt++; }else { dwCoreCnt += CountBits(pOffsite->ProcessorMask); } } break; case RelationProcessorPackage: dwPackageCnt++; break; default: break; } pOffsite++; } _tprintf(_T("处理器个数:%d\n"), dwPackageCnt); _tprintf(_T("处理器核数:%d\n"), dwCoreCnt); _tprintf(_T("NUMA个数:%d\n"), dwNodeCnt); _tprintf(_T("高速缓存的个数:%d\n"), dwCacheCnt); return 0; } DWORD CountBits(ULONG_PTR uMask) { DWORD dwTest = 1; DWORD LSHIFT = sizeof(ULONG_PTR) * 8 -1; dwTest = dwTest << LSHIFT; DWORD dwCnt = 0; for (int i = 0; i <= LSHIFT; i++) { dwCnt += ((uMask & dwTest) ? 1 : 0); dwTest /= 2; } return dwCnt; }这个程序首先采用两次调用的方式分配一个合适的缓冲区，用来接收函数的返回，然后分别统计CPU数目，物理处理器数目以及逻辑处理器数量。我们根据MSDN上面得到的信息，首先判断缓冲区中有多少个结构体，也就是由多少条处理器的信息，然后根据第二个成员的值，来判断当前存储的是哪种信息。并将对应的值加1，当计算逻辑处理器的数目时需要考虑超线程的问题，所谓超线程就是intel提供的一个新的技术，可以将一个处理器虚拟成多个处理器来使用，已达到多核处理器的效果，如果它支持超线程，那么久不能简单的根据是否为核心处理器而加1，这个时候需要采用计算位掩码的方式来统计逻辑存储器，根据MSDN上说的当flag为1时表示支持超线程。windows下的进程windows中进程是已装入内存中，准备或者已经在执行的程序，磁盘上的exe文件虽说可以执行，但是它只是一个文件，并不是进程，一旦它被系统加载到内存中，系统为它分配了资源，那么它就是一个进程。进程由两个部分组成，一个是系统内核用来管理进程的内核对象，一个是它所占的地址空间。windows下的进程主要分为3大类：控制台，窗口应用，服务程序。写过控制台与窗口程序的人都知道，控制台的主函数是main，而窗口应用的主函数是WinMain，那么是否可以根据这个来判断程序属于那种呢，很遗憾，windows并不是根据这个来区分的。在VS编译器上可以通过设置将Win32 控制台程序的主函数指定为WinMain，或者将窗口程序的主函数指定为main，设置方法：属性-->连接器-->系统-->子系统，将这项设置为/SUBSYSTEM:CONSOLE,那么它的主函数为main,设置为/SUBSYSTEM:WINDOWS那么它的主函数为WinMain，甚至我们可以自己设置主函数。我们知道在C/C++语言中main程序是从main函数开始的，但是这个函数只是语法上的开始，并不是真正意义上的入口，在VC++中，系统会首先调用mainCRTStartup，在这个函数中调用main或者WinMain， 这个函数主要负责对C/C++运行环境的初始化，比如堆环境或者C/C++库函数环境的初始化。如果需要自定义自己的入口，那么这些环境将得不到初始化，也就意味着我们不能使用C/C++库函数。只能使用VC++提供的API，这么做也有一定的好处，毕竟这些库函数都是在很早之前产生的，到现在来看有很多问题，有许多有严重的安全隐患，使用API可以避免这些问题。下面是一个简单的例子：#include <Windows.h> #include <tchar.h> #include <strsafe.h> #define PRINTF(...) \ {\ TCHAR szBuf[4096] = _T("");\ StringCchPrintf(szBuf, sizeof(szBuf), __VA_ARGS__);\ size_t nStrLen = 0;\ StringCchLength(szBuf, STRSAFE_MAX_CCH, &nStrLen);\ WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), szBuf, nStrLen, NULL, NULL);\ } int LHMain() { PRINTF(_T("this is a %s"), _T("test hello world\n")); return 0; }这个例子中，入口函数是LHMain我们完全使用API的方式来编写程序，如果想要做到自定义入口，那么需要进行这样的设置：属性-->高级-->入口点,在入口点中输出我们希望作为入口点的函数名称即可。入口参数各个参数的含义现在这部分主要说明main函数以及WinMain函数。int main()这是main函数的一种原型，这种原型不带入任何参数int main(int argc, char *argv[])这种原型主要接受命令行输入的参数，参数以空格隔开，第一个参数表示输入命令行参数的总数，第二个是一个字符串指针数组，每个字符串指针成员代表的是具体输入的命令以及参数，这些信息包括我们输入的程序的名称，比如我们输入test.exe -s -a -t 来启动程序，那么argc = 4 ，argv[0] = "test.exe" argv[1] = "-s" argv[2] = "-a" argv[3] = "-t"int main(int argc, char argv[], char envs[])这个原型中第一个和第二个参数的函数与上述的带有两个参数的main函数相同，多了一个表示环境变量的指针数组，它会将环境变量以”变量名=值“的形式来组织字符串。int WINAPI WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow);函数中的WINAPI表示函数的调用约定为__stdcall的调用方式，函数的调用方式主要与参数压栈方式以及环境回收的方式有关。在这就不再说明这部分的内容，有兴趣的可以看本人另外一篇博客专门讲解了这部分的内容，点击这里hInstance：进程的实例句柄，该值是exe文件映射到虚拟地址控件的基址hPrevInstance：上一个进程的实例句柄，为了防止进程越界访问，这个是16位下的产物，在32位下，这个没有作用。lpszCmdLine：启动程序时输入的命令行参数nCmdShow:表示程序的显示方式。进程的环境变量与工作路径进程的环境变量可以通过main函数的第三个参数传入，也可以在程序中利用函数GetEnvrionmentStrings和GetEnvrionVariable获取，下面是获取进程环境变量的简答例子: setlocale(CP_ACP, "chs"); TCHAR **ppArgs = NULL; int nArgCnt = 0; ppArgs = CommandLineToArgvW(GetCommandLine(), &nArgCnt); for (int i = 0; i < nArgCnt; i++) { _tprintf(_T("%d %s\n"), i, ppArgs[i]); } HeapFree(GetProcessHeap(), 0, ppArgs);函数的第一个参数是开启这个进程需要的完整的命令行字符串，这个字符串使用函数GetCommandLine来获取，第二个参数是一个接受环境变量的字符串指针数组。函数返回数组中元素个数。一般情况下不推荐使用环境变量的方式来保存程序所需的数据，一般采用文件或者注册表的方式，但是最好的办法是采用xml文件的方式来村粗。至于进程的工作目录可以通过函数GetCurrentDirectory方法获取。进程创建在windows下进程创建采用API函数CreateProcess，该函数的原型如下：BOOL CreateProcess( LPCWSTR pszImageName, LPCWSTR pszCmdLine, LPSECURITY_ATTRIBUTES psaProcess, LPSECURITY_ATTRIBUTES psaThread, BOOL fInheritHandles, DWORD fdwCreate, LPVOID pvEnvironment, LPWSTR pszCurDir, LPSTARTUPINFOW psiStartInfo, LPPROCESS_INFORMATION pProcInfo ); 该函数参数较多，下面对这几项做重点说明，其余的请自行查看MSDN。pszImageName：表示进程对应的exe文件所在的完整路径或者相对路径pszCmdLine：启动进程传入的命令行参数，这是一个字符串类型，需要注意的是，这个命令行参数可以带程序所在的完整路径，这样就可以将第一个参数设置为NULL。参数中的安全描述符表示的是创建的子进程的安全描述符，与当前进程的安全描述符无关。fInheritHandles表示，可否被继承，这个继承关系是指父进程中的信息能否被子进程所继承psiStartInfo规定了新进程的相关启动信息，主要有这样几个重要的值：对于窗口程序： LPTSTR lpTitle; DWORD dwX; DWORD dwY; DWORD dwXSize; DWORD dwYSize;这些值规定了窗口的标题和所在的屏幕位置与长高的相关信息，对于控制台程序，主要关注： HANDLE hStdInput; HANDLE hStdOutput; HANDLE hStdError;标准输入、输出、以及标准错误 下面是一个创建控制台与创建窗口的简单例子： STARTUPINFO si = {0}; si.dwXSize = 400; si.dwYSize = 300; si.dwX = 10; si.dwY = 10; PROCESS_INFORMATION pi = {0}; SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES)}; //创建一个窗口应用的进程，其中szExePath表示进程所在exe文件的路径，而szAppDirectory表示exe所在的目录 CreateProcess(szExePath, szExePath, &sa, &sa, FALSE, 0, NULL, szAppDirectory, &si, &pi); WaitForSingleObject(pi.hProcess, INFINITE); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); //启动控制台窗口,与父进程公用输入输出环境 ZeroMemory(szExePath, sizeof(TCHAR) * (MAX_PATH + 1)); StringCchPrintf(szExePath, MAX_PATH, _T("%s%s"), szAppDirectory, _T("SubConsole.exe")); ZeroMemory(&si, sizeof(STARTUPINFO)); ZeroMemory(&pi, sizeof(PROCESS_INFORMATION)); CreateProcess(szExePath, szExePath, &sa, &sa, FALSE, 0, NULL, szAppDirectory, &si, &pi); WaitForSingleObject(pi.hProcess, INFINITE); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); //启动控制台，在新的控制台上做输入输出 ZeroMemory(&si, sizeof(STARTUPINFO)); ZeroMemory(&pi, sizeof(PROCESS_INFORMATION)); CreateProcess(szExePath, szExePath, &sa, &sa, FALSE, CREATE_NEW_CONSOLE, NULL, szAppDirectory, &si, &pi); WaitForSingleObject(pi.hProcess, INFINITE); CloseHandle(pi.hProcess); CloseHandle(pi.hThread);上述程序中，对于窗口程序，在创建时没有给出特别的创建标志，窗口本身就是一个个独立的，并且我们通过指定si的部分成员指定了窗口的显示位置，而对于控制台，如果在创建时不特别指定创建的标志，那么它将与父进程共享一个输入输出控制台。为了区分子进程和父进程的输入输出，一般通过标志CREATE_NEW_CONSOLE为新进程新建一个另外的控制台。进程输入输出重定向输入输出重定向的实现可以通过函数CreateProcess在参数psiStartInfo中的HANDLE hStdInput; HANDLE hStdOutput; HANDLE hStdError中指定，但是需要注意的是，在父进程中如果采用了Create之类的函数创建了输入输出对象的句柄时一定要指定他们可以被子进程所继承。下面是一个重定向的例子： //启动控制台，做输入输出重定向到文件中 TCHAR szFilePath[MAX_PATH + 1] = _T(""); //指定文件对象可以被子进程所继承，以便子进程可以使用这个内核对象句柄 sa.bInheritHandle = TRUE; ZeroMemory(&si, sizeof(STARTUPINFO)); ZeroMemory(&pi, sizeof(PROCESS_INFORMATION)); StringCchPrintf(szFilePath, MAX_PATH, _T("%s%s"), szAppDirectory, _T("input.txt")); HANDLE hInputFile = CreateFile(szFilePath, GENERIC_READ | GENERIC_WRITE, 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); ZeroMemory(szFilePath, sizeof(szFilePath)); StringCchPrintf(szFilePath, MAX_PATH, _T("%s%s"), szAppDirectory, _T("output.txt")); HANDLE hOutputFile = CreateFile(szFilePath, GENERIC_READ | GENERIC_WRITE, 0, &sa, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); si.hStdInput = hInputFile; si.hStdOutput = hOutputFile; si.dwFlags = STARTF_USESTDHANDLES; CreateProcess(szExePath, szExePath,NULL, NULL, TRUE, DETACHED_PROCESS, NULL, szAppDirectory, &si, &pi); WaitForSingleObject(pi.hProcess, INFINITE); CloseHandle(hOutputFile); CloseHandle(hInputFile); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); //启动ping命令，并将输出重定向到管道中 StringCchPrintf(szExePath, MAX_PATH, _T("ping 127.0.0.1")); DWORD dwLen = 0; BYTE byte[1024] = {0}; HANDLE hReadP = NULL; HANDLE hWriteP = NULL; sa.bInheritHandle = TRUE; CreatePipe(&hReadP, &hWriteP, &sa, 1024); si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE; si.hStdOutput = hWriteP; CreateProcess(NULL, szExePath, NULL, NULL, TRUE, DETACHED_PROCESS, NULL, szAppDirectory, &si, &pi); //关闭管道的写端口，不然读端口会被阻塞 CloseHandle(hWriteP); dwLen = 1000; DWORD dwRead = 0; while (ReadFile(hReadP, byte, dwLen, &dwRead, NULL)) { if ( 0 == dwRead ) { break; } //写入管道的数据为ANSI字符 printf("%s\n", (char*)byte); ZeroMemory(byte, sizeof(byte)); }进程的退出进程在遇到如下情况中的任意一种时会退出：进程中任意一个线程调用函数ExitProcess进程的主线程结束进程中最后一个线程结束调用TerminateProcess在这针对第2、3中情况作特别的说明：这两种情况看似矛盾不是吗，当主线程结束时进程就已经结束了，这个时候还会等到最后一个线程吗。其实真实的情况是主线程结束，进程结束这个限制是VC++上的，之前在自定义入口的时候说过，main函数只是语法上的，并不是实际的入口，在调用main之前会调用mainCRTStartup，这个函数会负责调用main函数，当main函数调用结束后，这个函数会隐式的调用ExitProcess结束进程，所以只有当我们自定了程序入口才会看到3所示的现象，下面的例子说明了这点：DWORD WINAPI ThreadProc(LPVOID lpParam); #define PRINT(s) \ {\ size_t sttLen = 0;\ StringCchLengthA(s, 1024, &sttLen);\ WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), s, sttLen, NULL, NULL);\ } int LHMain(int argc, char *argv[]) { CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL); return 0; } DWORD WINAPI ThreadProc(LPVOID lpParam) { PRINT("main thread is ending,this is child thread\r\n"); return 0; }这种程序，如果我们采用系统中规定的main函数的话，是看不到线程中输出的信息的，因为主线程先结束的话，整个进程就结束了，线程还来不及输出，就被终止了。但是我们采用自定义入口的方式，屏蔽了这个特性，所以它会等到所有线程执行完成后才会结束，这个时候就会看到这句话输出了。进程在终止时会发生以下事件：关闭进程打开的对象句柄，但是对象本身不一定会关闭，这是因为每个对象都有一个计数器，每当有一个线程在使用这个对象时计数器会加1，而释放它的句柄时会减一，只有当计数器为0时才会销毁这个对象。对象是可以跨进程访问的，而且所有相同的对象在内存中只有一份，所以需要一个计数器以便在没有被任何进程访问的时候系统删除它。进程对象的状态设为有信号，以便所有等待该进程对象信号的函数（像函数WaitForSingleObject）能够正常返回。进程的终止状态从STILL_ACTIVE变成进程的退出码，可以通过这个特性判断某个进程是否在运行，具体的方式是通过函数GetExitProcess获取进程的终止码，如果函数返回STILL_ACTIVE，则说明进程仍在运行。

windows 安全模型简介 操作系统中有些资源是不能由用户代码直接访问的，比如线程进程，文件等等，这些资源必须由系统级代码由RING3层进入到RING0层操作，并且返回一些标识供用户程序使用，一般调用某个函数陷入到内核，这样的函数叫做系统调用，而有些不直接陷入到内核，一般叫做系统API，linux中使用系统调用，而windows中封装了一系列的API。windows对象与句柄windows对象操作系统为了安全，提供了一种保护机制，这种机制会禁止用户操作某些资源，避免用户过于关注细节，或者由于操作不当而造成系统崩溃。windows中将所有这些资源封装成了一个个对象。对象就是操作系统为了维护这些资源而定义的一系列的数据结构。对象这个词我们很容易联想到面向对象编程语言中的对象，对象其实就是对一些数据以及操作这些数据的一个封装，而windows是采用面向对象思想开发的，所以我们可以将windows中的对象想象成面向对象中的对象，而windows针对每种对象都提供了操作函数，这些函数一般都会以句柄作为第一个参数，这就有点像类函数中传入的this指针。而这操作对象的函数就是类函数。windows中总共有三种对象：GUI对象、GDI对象、内核对象。windows中的句柄windows中对象的操作是由系统提供的一系列的API函数来完成，这些函数有一个共同特点，就是以HANDLE 句柄作为第一个参数，windows中采用句柄来唯一标识每个内核对象。在windows中句柄的定义如下：typedef void * HANDLE从上面的定义可以看出，这个句柄应该是指向这个对象的结构体的指针。由于每次在程序启动时内存都是随机分配的，所以句柄不要使用硬编码的方式，同时在复制内核对像的时候，并不是简单的复制它的句柄，对象的复制有专门的函数，DuplicateHandle,该函数原型如下：BOOL DuplicateHandle( HANDLE hSourceProcessHandle, //源对象所在进程句柄 HANDLE hSourceHandle, //源对象句柄 HANDLE hTargetProcessHandle, //目标对象所在进程句柄 LPHANDLE lpTargetHandle, //返回目标对象的句柄 DWORD dwDesiredAccess, //以何种权限复制 BOOL bInheritHandle, //复制的对象句柄是否可继承 DWORD dwOptions //标记一些特殊的动作 );下面是一个例子代码：HANDLE hMutex = CreateMutex(NULL, FALSE, NULL); HANDLE hMutexDup, hThread; DWORD dwThreadId; DuplicateHandle(GetCurrentProcess(),hMutex,GetCurrentProcess(),&hMutexDup, 0,FALSE,DUPLICATE_SAME_ACCESS);上述代码在本进程中复制了一个互斥对象对象的句柄。windows 安全对象模型windows中的内核对象由进程和线程进行操作，而对象就好像一个被锁上的房间，进程想要访问对象，并对对象进程某种操作，就必须获取这个对象的钥匙，而线程就好像拥有钥匙的人，只有钥匙是对的，才可以访问。这把锁能够由不同的钥匙打开，这些钥匙信息存储在ACE中，而只有当ACE中的信息与访问字串这个钥匙匹配才可以打开。我们一般把这个钥匙称为访问字串（Token）访问字串访问字串主要包括：用户标识、组标识、优先权信息、以及其他访问信息。用户标识：用于唯一标识每个用户，就好像为每个用户都分配了一个唯一的用户ID组标识：用户所属组的唯一标识ID优先权：一般系统对每个用户以及它所属组分配了一些权限，而有的时候这些权限并不够，这个时候需要通过这个优先权信息额外新增一些权限当用户登录windows系统时，系统就为这个用户分配了一个带有该用户信息的访问字串，该用户创建的每个安全对象都有这个访问字串的拷贝，当用户打开的进程试图访问某个安全对象时系统就在对象的ACL中查找该用户是否有某项权限。有这个权限才能对对象进行这项操作。子进程的访问字串一般继承与父进程，但是子进程也可以自行创建访问字串来覆盖原来的访问字串。操作访问字串所使用的API主要有以下几个：OpenProcessToken //打开进程的访问令牌OpenThreadToken //打开线程的访问令牌AdjustTokenGroups //改变用户组的访问令牌AdjustTokenPrivileges //改变令牌的访问特权GetTokenInformation //获取访问令牌的信息SetTokenInformation //设置访问令牌信息下面主要介绍一下函数GetTokenInformation 的用法：BOOL WINAPI GetTokenInformation( __in HANDLE TokenHandle, //访问字串的句柄 __in TOKEN_INFORMATION_CLASS TokenInformationClass, //需要返回访问字串哪方面的信息 __out_opt LPVOID TokenInformation, //用于接收返回信息的缓冲 __in DWORD TokenInformationLength, //缓冲的长度 __out PDWORD ReturnLength //实际所需的缓冲的长度 ); 这个函数可以返回访问令牌多方面的信息，具体返回哪个方面的信息，需要通过第二个参数来指定，这个参数是一个枚举类型，表示需要获取的信息，每个方面的信息都定义了对应的结构体，这些信息可以由MSDN中查到。另外这个函数支持两次调用，第一次传入NULL指针和0长度，这样通过最后一个参数可以得到具体所需要的缓冲的大小。SID访问字串中用户与用户组采用安全标识符的方式唯一标识（Security Indentifer SID）,系统中的SID是唯一的。它主要用来标识下面的这些内容：安全描述符中的所有者和用户组被ACE认可的访问者访问字串的用户和组SID的长度是可变的，在使用时不应该使用SID这个数据类型，因为这个时候还不知道需要的长度是多少，应该由系统来创建并返回它的指针，所以在使用时需要使用SID的指针。下面是一些操作SID的APIAllocateAndInitializeSid //初始化一个SIDFreeSid //释放一个SIDCopySid //拷贝一个SIDEqualSid //判断两个SID是否相等GetLengthSid //获取SID的长度IsValidSid //是否是有效的SIDConvertSidToStringSid //将SID转化为字符串的方式下面是一个利用这些API获取系统用户组的SID和当前登录用户的SID的例子：BOOL GetLoginSid(HANDLE hToken, PSID *ppsid); //SID本身大小是不可知的，所以在传入参数时应该传入2级指针，由函数自己决定大小 void FreeSid(PSID *ppsid); int _tmain(int argc, TCHAR* argv[]) { setlocale(LC_ALL, "chs"); HANDLE hProcess = GetCurrentProcess(); HANDLE hToken = NULL; OpenProcessToken(hProcess, TOKEN_ALL_ACCESS, &hToken); PSID pSid = NULL; GetLoginSid(hToken, &pSid); LPTSTR pStringSid = NULL; ConvertSidToStringSid(pSid, &pStringSid); _tprintf(_T("当前登录的用户sid = %s\n"), pStringSid); FreeSid(&pSid); return 0; } BOOL GetLoginSid(HANDLE hToken, PSID *ppsid) { TOKEN_GROUPS *ptg = NULL; BOOL bSuccess = FALSE; DWORD dwLength = 0; if(!GetTokenInformation(hToken, TokenGroups, ptg, 0, &dwLength)) { if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { goto __CLEAN_UP; } ptg = (TOKEN_GROUPS*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwLength); if (!GetTokenInformation(hToken, TokenGroups, ptg, dwLength, &dwLength)) { goto __CLEAN_UP; } } _tprintf(_T("共找到%d个组SID\n"), ptg->GroupCount); LPTSTR pStringSid = NULL; for (int i = 0; i < ptg->GroupCount; i++) { ConvertSidToStringSid(ptg->Groups[i].Sid, &pStringSid); _tprintf(_T("\t id = %d sid = %s"), i, pStringSid); if ((ptg->Groups[i].Attributes & SE_GROUP_LOGON_ID) == SE_GROUP_LOGON_ID) { _tprintf(_T("此用户为当前登录的用户")); *ppsid = (PSID)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwLength); CopySid(dwLength, *ppsid, ptg->Groups[i].Sid); } _tprintf(_T("\n")); } __CLEAN_UP: if (ptg != NULL) { HeapFree(GetProcessHeap(), 0, ptg); } return bSuccess; } void FreeSid(PSID *ppsid) { HeapFree(GetProcessHeap(), 0, *ppsid); *ppsid = NULL; }这个例子是MSDN中的一个例子，上述代码中首先获取进程的访问令牌，然后通过函数GetTokenInformation 获取访问令牌的信息。通过传入TokenGroups这个值获取当前用户所在用户组的访问字串。并将信息保存到结构体TOKEN_GROUPS中最后通过(ptg->Groups[i].Attributes & SE_GROUP_LOGON_ID) == SE_GROUP_LOGON_ID这样一个表达式来判断当前的SID是否是登录用户的。优先权优先权是由字符串标识的局部唯一的标识符（LUID)优先权是由系统管理员分配给对应的用户，一般不能通过编程的方式提升用户的优先权，但是有时候即使用户具有某个优先权，但是它启动的程序并不具有相关的优先权。这个时候可以通过编程的方式提升用户进程特权。系统有3个值代表一个优先权：字符串名，整个系统上都有意义，称为全局名，这个字符串并不是一个可读的字符串，显示出来的信息不一定能看得懂。显示给用户的可读名称；如：改变系统时间（可以在组策略中查看）每个计算机都不同的局部值；下面有几个常用的优先权：#define SE_DEBUG_NAME TEXT("SeDebugPrivilege") //调试进程 #define SE_LOAD_DRIVER_NAME TEXT("SeLoadDriverPrivilege") //装载驱动 #define SE_LOCK_MEMORY_NAME TEXT("SeLockMemoryPrivilege") //锁定内存页面 #define SE_SHUTDOWN_NAME TEXT("SeShutdownPrivilege") //关机下面是几个优先权函数LookupPrivilegeValue //查询优先权的值LookupPrivilegeDisplayName //查询优先权的输出名LookupPrivilegeName //查询优先权的名称PrivilegeCheck //优先权信息检查下面是一个获取用户特权信息的代码：int _tmain(int argc, TCHAR *argv[]) { setlocale(LC_ALL, "chs"); HANDLE hToken = NULL; HANDLE hProcess = GetCurrentProcess(); OpenProcessToken(hProcess, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken); TOKEN_PRIVILEGES* ptg = NULL; DWORD dwTgSize = 0; TCHAR szName[255] = _T(""); TCHAR szDisplay[255] = _T(""); DWORD languageID = GetUserDefaultLangID(); if (!GetTokenInformation(hToken, TokenPrivileges, ptg, 0, &dwTgSize)) { if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { _tprintf(_T("获取令牌失败\n")); return 0; } ptg = (TOKEN_PRIVILEGES*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwTgSize); if (!GetTokenInformation(hToken, TokenPrivileges, ptg, dwTgSize, &dwTgSize)) { _tprintf(_T("读取令牌信息失败\n")); return 0; } } _tprintf(_T("用户的特权信息:\n")); for(int i = 0; i < ptg->PrivilegeCount; i++) { DWORD dwName = sizeof(szName) / sizeof(TCHAR); DWORD dwDisplay = sizeof(szDisplay) / sizeof(TCHAR); LookupPrivilegeName(NULL, &ptg->Privileges[i].Luid, szName, &dwName); LookupPrivilegeDisplayName(NULL, szName, szDisplay, &dwDisplay, &languageID); _tprintf(_T("\t 特权名%s %s"), szName, szDisplay); if (ptg->Privileges[i].Attributes & ((SE_PRIVILEGE_ENABLED | SE_PRIVILEGE_ENABLED_BY_DEFAULT))) { _tprintf(_T("特权开放\n")); }else { _tprintf(_T("特权关闭\n")); } } HeapFree(GetProcessHeap(), 0, ptg); return 0; }下面是进程提权的代码：int _tmain(int argc, TCHAR *argv[]) { HANDLE hToken = NULL; HANDLE hProcess = GetCurrentProcess(); SetPrivileges(hToken, SE_TCB_NAME , TRUE); return 0; } BOOL SetPrivileges(HANDLE hToken, LPTSTR lpPrivilegesName, BOOL bEnablePrivilege) { //获取Token的特权信息 LUID uid = {0}; LookupPrivilegeValue(NULL, lpPrivilegesName, &uid); TOKEN_PRIVILEGES tp = {0}; tp.PrivilegeCount = 1; tp.Privileges[0].Luid = uid; if (bEnablePrivilege) { tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; }else { tp.Privileges[0].Attributes = 0; } AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL); if ( GetLastError() == ERROR_NOT_ALL_ASSIGNED ) { _tprintf(_T("分配指定的特权(%s)失败. \n"),lpPrivilegesName); return FALSE; } return TRUE; }安全描述符安全描述符中通常包含信息：所有者、主组、任选访问控制列表（DACL）、系统访问控制列表（SACL）安全描述符是以SECURITE_DESCRIPTOR结构开始，后面连续跟着安全描述符的其它信息访问控制列表访问控制列表（Access Control List ACL）主要由多个访问访问控制入口（Access Control Entries ACE）组成。ACE用于标识一个用户、组或局部组以及它们中每一个允许的访问权；安全描述符的创建在创建安全访问对象的函数中一般都需要填入一个SECURITY_ATTRIBUTES结构体的指针，我们要么给定一个NULL值使其具有默认的安全属性，或者自己创建一个安全描述符并将他的指针传入。创建一个安全描述符主要有下面几步：用函数 AllocateAndInitializeSid 创建用户的SID。函数的定义如下：BOOL WINAPI AllocateAndInitializeSid( __in PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, //用于表示该SID标识的颁发机构 __in BYTE nSubAuthorityCount, //SID有多少个子部分 __in DWORD dwSubAuthority0, //第0个子部分 __in DWORD dwSubAuthority1, __in DWORD dwSubAuthority2, __in DWORD dwSubAuthority3, __in DWORD dwSubAuthority4, __in DWORD dwSubAuthority5, __in DWORD dwSubAuthority6, __in DWORD dwSubAuthority7, __out PSID* pSid //返回一个PSID的指针 );SID主要由一个颁发机构以及一个或者多个32位的唯一的RID组成这些RID通过参数dwSubAuthority0到dwSubAuthority7生成。对应的用户SID都有固定的组合。这个我还没找到具体的用户与SID是如何定义的。为该用户SID分配访问控制权限，主要通过填充结构体EXPLICIT_ACCESS成员来实现，这个结构体的定义如下：typedef struct _EXPLICIT_ACCESS { DWORD grfAccessPermissions; //制定用户权限 ACCESS_MODE grfAccessMode; //用于表示允许、拒绝、审查特定用户的权限 DWORD grfInheritance; //当前的权限是否可以继承 TRUSTEE Trustee; //这是一个访问托管 } EXPLICIT_ACCESS, *PEXPLICIT_ACCESS;3.用API SetEntriesInAcl将上述结构体放入到ACL中分配并初始化SECURITY_DESCRIPTOR结构体，初始化该结构体所用到的API 是InitializeSecurityDescriptor将SECURITY_DESCRIPTOR结构加入到安全描述符中，安全描述符的结构体是：SECURITY_ATTRIBUTES下面是一个具体的例子(这个例子来自MSDN)： SID_IDENTIFIER_AUTHORITY SIDAuthorityNT = SECURITY_WORLD_SID_AUTHORITY; SID_IDENTIFIER_AUTHORITY SIDAuthorityWord = SECURITY_NT_AUTHORITY; PSID pEveryOneSid = NULL; PSID pAdminSid = NULL; EXPLICIT_ACCESS ea[2] = {0}; PACL pAcl = NULL; //创建everyone用户的SID AllocateAndInitializeSid(&SIDAuthorityWord, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pEveryOneSid); PSECURITY_DESCRIPTOR pSD = NULL; //定义everyone 的访问控制信息 ea[0].grfAccessMode = SET_ACCESS; //用于表示允许、拒绝、审查特定用户的权限 ea[0].grfAccessPermissions = KEY_READ; //制定用户权限 ea[0].grfInheritance = FALSE; ea[0].Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP; ea[0].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[0].Trustee.ptstrName = (LPTSTR)pEveryOneSid; //创建administor用户组的SID AllocateAndInitializeSid(&SIDAuthorityNT, 2, SECURITY_BUILTIN_DOMAIN_RID,DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &pAdminSid); ea[1].grfAccessMode = SET_ACCESS; ea[1].grfAccessPermissions = KEY_ALL_ACCESS; ea[1].grfInheritance = FALSE; ea[1].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[1].Trustee.TrusteeType = TRUSTEE_IS_GROUP; ea[1].Trustee.ptstrName = (LPTSTR)pAdminSid; //将以上两个SID加入到ACL中 SetEntriesInAcl(2, ea, NULL, &pAcl); pSD = (PSECURITY_DESCRIPTOR) HeapAlloc(GetProcessHeap(), 0, SECURITY_DESCRIPTOR_MIN_LENGTH); //初始化一个SECURITY_DESCRIPTOR结构 InitializeSecurityDescriptor(&pSD, SECURITY_DESCRIPTOR_REVISION); //将SECURITY_DESCRIPTOR结构加入到安全描述符中 SECURITY_ATTRIBUTES sa = {0}; sa.bInheritHandle = FALSE; sa.lpSecurityDescriptor = pSD; sa.nLength = sizeof(SECURITY_ATTRIBUTES); HKEY hkSub = NULL; DWORD dwDisposition = 0; RegCreateKeyEx(HKEY_CURRENT_USER, _T("mykey"), 0, _T(""), 0, KEY_READ | KEY_WRITE, &sa, &hkSub, &dwDisposition); if (pEveryOneSid) { FreeSid(pEveryOneSid); } if (pAdminSid) { FreeSid(pAdminSid); } if (pAcl) { LocalFree(pAcl); } HeapFree(GetProcessHeap(), 0, pSD); if (hkSub) { RegCloseKey(hkSub); }

windows 异常处理 为了程序的健壮性，windows 中提供了异常处理机制，称为结构化异常，异常一般分为硬件异常和软件异常，硬件异常一般是指在执行机器指令时发生的异常，比如试图向一个拥有只读保护的页面写入内容，或者是硬件的除0错误等等，而软件异常则是由程序员，调用RaiseException显示的抛出的异常。对于一场处理windows封装了一整套的API，平台上提供的异常处理机制被叫做结构化异常处理（SEH）。不同于C++的异常处理，SEH拥有更为强大的功能，并且采用C风给的代码编写方式。异常处理机制的流程简介一般当程序发生异常时，用户代码停止执行，并将CPU的控制权转交给操作系统，操作系统接到控制权后，将当前线程的环境保存到结构体CONTEXT中，然后查找针对此异常的处理函数。系统利用结构EXCEPTION_RECORD保存了异常描述信息，它与CONTEXT一同构成了结构体EXCEPTION_POINTERS，一般在异常处理中经常使用这个结构体。异常信息EXCEPTION_RECORD的定义如下typedef struct _EXCEPTION_RECORD { DWORD ExceptionCode; //异常码 DWORD ExceptionFlags; //标志异常是否继续，标志异常处理完成后是否接着之前有问题的代码 struct _EXCEPTION_RECORD* ExceptionRecord; //指向下一个异常节点的指针，这是一个链表结构 PVOID ExceptionAddress; //异常发生的地址 DWORD NumberParameters; //异常附加信息 ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; //异常的字符串 } EXCEPTION_RECORD, *PEXCEPTION_RECORD;当系统在用户程序中查找异常处理代码时主要通过查找当前的这个链表。下面详细说明异常发生时操作系统是如何处理的：如果程序是被调试运行的（比如我们在VS编译器中调试运行程序），当异常发生时，系统首先将异常信息交给调试程序，如果调试程序处理了那么程序继续运行，否则系统便在发生异常的线程栈中查找可能的处理代码。若找到则处理异常，并继续运行程序如果在线程栈中没有找到，则再次通知调试程序，如果这个时候仍然不能处理这个异常，那么操作系统会对异常进程默认处理，比如强制终止程序。SEH的基本框架结构化异常处理一般有下面3个部分组成：保护代码体过滤表达式异常处理块其中保护代码体：是指有可能发生异常的代码，一般在SEH中是用__try{}包含的那部分过滤表达式：是在__except表达式的括号中的部分，一般可以是函数或者表达式，过滤表达式一般只能返回3个值：EXCEPTION_CONTINUE_SEARCH表示继续向下寻找异常处理的程序，也就是说本__exception不能处理这个异常；EXCEPTION_CONTINUE_EXECUTION表示异常已被处理，继续执行当初发生异常的代码；EXCEPTION_EXECUTE_HANDLER：表示异常已被处理，直接跳转到__exception(){}代码块中执行，这个时候就有点像C++中的异常处理了。一般一个__try块可以跟随多个__except块异常处理块：是指__except大括号中的代码块另外可以在过滤表达式中调用GetExceptionCode和GetExceptionInformagtion函数取得正在处理的异常信息,这两个函数不能再过滤表达式中使用，但是可以作为过滤表达式中的函数参数。下面是一个异常处理的简单的例子：#define PAGELIMIT 1024 DWORD dwPageCnt = 0; LPVOID lpPrePage = NULL; DWORD dwPageSize = 0; INT FilterFunction(DWORD dwExceptCode) { if(EXCEPTION_ACCESS_VIOLATION != dwExceptCode) { return EXCEPTION_EXECUTE_HANDLER; } if(dwPageCnt >= PAGELIMIT) { return EXCEPTION_EXECUTE_HANDLER; } if(NULL == VirtualAlloc(lpPrePage, dwPageSize, MEM_COMMIT, PAGE_READWRITE)) { return EXCEPTION_EXECUTE_HANDLER; } lpPrePage = (char*)lpPrePage + dwPageSize; dwPageCnt++; return EXCEPTION_CONTINUE_EXECUTION; } int _tmain(int argc, TCHAR *argv[]) { SYSTEM_INFO si = {0}; GetSystemInfo(&si); dwPageSize = si.dwPageSize; char* lpBuffer = (char*)VirtualAlloc(NULL, dwPageSize * PAGELIMIT, MEM_RESERVE, PAGE_READWRITE); lpPrePage = lpBuffer; for(int i = 0; i < PAGELIMIT * dwPageSize; i++) { __try { lpBuffer[i] = 'a'; } __except(FilterFunction(GetExceptionCode())) { ExitProcess(0); } } VirtualFree(lpBuffer, dwPageSize * PAGELIMIT, MEM_FREE); return 0; }这段代码我们通过结构化异常处理实现了内存的按需分配，首先程序保留了4M的地址空间，但是并没有映射到具体的物理内存，接着向这4M的空间中写入内容，这个时候会造成非法的内存访问异常，系统会执行过滤表达式中调用的函数，在函数中校验异常的异常码，如果不等于EXCEPTION_ACCESS_VIOLATION，也就是说这个异常并不是读写非法内存造成的，那么直接返回EXCEPTION_EXECUTE_HANDLER，这个时候会执行__exception块中的代码，也就是结束程序，如果是由于访问非法内存造成的，并且读写的范围没有超过4M那么就提交一个物理页面供程序使用，并且返回EXCEPTION_CONTINUE_EXECUTION，让程序接着从刚才的位置执行也就是说再次执行写入操作，这样保证了程序需要多少就提交多少，节约了物理内存。终止处理块终止处理块是结构化异常处理特有的模块，它保证了当__try块执行完成后总会执行终止处理块中的代码。一般位于__finally块中。只有当线程在__try中结束，也就是在__try块中调用ExitProcess或者ExitThread。由于系统为了保证__try块结束后总会调用__finally所以某些跳转语句如：goto return break等等就会添加额外的机器码以便能够跳入到__try块中，所以为了效率可以用__leave语句代替这些跳转语句。另外需要注意的一点是一个__try只能跟一个__finally块但是可以跟多个__except块。同时__try块后面要么跟__except要么跟__finally这两个二选一，不能同时跟他们两个。抛出异常在SEH中抛出异常需要使用函数:RaiseException，它的原型如下：void WINAPI RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, const ULONG_PTR* lpArguments);第一个是异常代码，第二个参数是异常标志，第三个是异常参数个数，第四个是参数列表，这个函数主要是为了填充EXCEPTION_RECORD结构体并将这个节点添加到链表中，当发生异常时系统会查找这个链表,下面是一个简单的例子:DWORD FilterException() { wprintf(_T("1\n")); return EXCEPTION_EXECUTE_HANDLER; } int _tmain(int argc, TCHAR *argv[]) { __try { __try { RaiseException(1, 0, 0, NULL); } __finally { wprintf(_T("2\n")); } } __except(FilterException()) { wprintf(_T("3\n")); } _tsystem(_T("PAUSE")); return 0; }上面的程序使用RaiseException抛出一个异常，按照异常处理的流程，程序首先会试着执行FilterException，以便处理这个异常，所以首先会输出1，然后根据返回值EXCEPTION_EXECUTE_HANDLER决定下一步会执行异常处理块__except中的内容，这个时候也就表示最里面的__try块执行完了，在前面说过，不管遇到什么情况，执行完__try块，都会接着执行它对应的__finally块，所以这个时候会首先执行__finally块，最后执行外层的__except块，最终程序输出结果为1 2 3win32下的向量化异常处理为什么向量化异常要强调是win32下的呢，因为64位windows不支持这个特性理解这个特性还是回到之前说的操作系统处理异常的顺序上面，首先会交给调试程序，然后再由用户程序处理，根据过滤表达式返回的值决定这个异常是否被处理，而这个向量化异常处理，就是将异常处理的代码添加到这个之前，它的代码会先于过滤表达式之前执行。我们知道异常是由内层向外层一层一层的查找，如果在内层已经处理完成，那么外层是永远没有机会处理的，这种情况在我们使用第三方库开发应用程序，而这个库又不提供源码，并且当发生异常时这个库只是简单的将线程终止，而我们想处理这个异常，但是由于内部处理了，外层的try根本捕获不到，这个时候就可以使用向量化异常处理了。这样我们可以编写异常处理代码先行处理并返回继续执行，这样库中就没有机会处理这个异常了。使用这个机制通过AddVectoredExceptionHandler函数可以添加向量化异常处理过滤函数，而调用RemoveVectoredExceptionHandler可以移除一个已添加的向量化异常处理过滤函数。下面是一个简单的例子：int g_nVal = 0; void Func(int nVal) { __try { nVal /= g_nVal; } __except(EXCEPTION_EXECUTE_HANDLER) { printf("正在执行Func中的__try __except块\n"); ExitProcess(0); } } LONG CALLBACK VH1(PEXCEPTION_POINTERS pExceptionInfo) { printf("正在执行VH1()函数\n"); return EXCEPTION_CONTINUE_SEARCH; } LONG CALLBACK VH2(PEXCEPTION_POINTERS pExceptionInfo) { printf("正在执行VH2()函数\n"); if (EXCEPTION_INT_DIVIDE_BY_ZERO == pExceptionInfo->ExceptionRecord->ExceptionCode) { g_nVal = 25; return EXCEPTION_CONTINUE_EXECUTION; } return EXCEPTION_CONTINUE_SEARCH; } LONG CALLBACK VH3(PEXCEPTION_POINTERS pExceptionInfo) { printf("正在执行VH3()函数\n"); return EXCEPTION_CONTINUE_SEARCH; } LONG SEH1(EXCEPTION_POINTERS *pEP) { //除零错误 if (EXCEPTION_INT_DIVIDE_BY_ZERO == pEP->ExceptionRecord->ExceptionCode) { g_nVal = 34; return EXCEPTION_EXECUTE_HANDLER; } return EXCEPTION_CONTINUE_SEARCH; } int _tmain(int argc, TCHAR *argv[]) { LPVOID lp1 = AddVectoredExceptionHandler(0, VH1); LPVOID lp2 = AddVectoredExceptionHandler(0, VH2); LPVOID lp3 = AddVectoredExceptionHandler(1, VH3); __try { Func(g_nVal); printf("Func()函数执行完成后g_nVal = %d\n", g_nVal); } __except(SEH1(GetExceptionInformation())) { printf("正在执行main()中的__try __except块"); } RemoveVectoredExceptionHandler(lp1); RemoveVectoredExceptionHandler(lp2); RemoveVectoredExceptionHandler(lp3); return 0; }上述的程序模拟了调用第三方库的情况，比如我们调用了第三方库Func进行某项操作，我们在外层进行了异常处理，但是由于在Func函数中有异常捕获的代码，所以不管外层如何处理，总不能捕获到异常，外层的异常处理代码总是不能执行，这个时候我们注册了3个向量处理函数，由于VH1返回的是EXCEPTION_CONTINUE_SEARCH，这个时候会在继续执行后面注册的向量函数——VH2，VH2返回EXCEPTION_CONTINUE_SEARCH，会继续执行VH3，VH3还是返回EXCEPTION_CONTINUE_SEARCH，那么它会继续执行库函数内层的异常处理，内层的过滤表达式返回EXCEPTION_EXECUTE_HANDLER，这个时候会继续执行异常处理块中的内容，结束程序，如果我们将3个向量函数中的任何一个的返回值改为EXCEPTION_CONTINUE_EXECUTION，那么库中的异常处理块中的内容将不会被执行。函数AddVectoredExceptionHandler中填入的处理函数也就是上述代码中的VH1 VH2 VH3只能返回EXCEPTION_CONTINUE_EXECUTION和EXCEPTION_CONTINUE_SEARCH，对于其他的值操作系统不认。将SEH转化为C++异常C++异常处理并不能处理所有类型的异常而将SEH和C++异常混用，可以达到使用C++异常处理处理所有异常的目的要混用二者需要在项目属性->C/C++->代码生成->启动C++异常的选项中打开SEH开关。在混用时可以在SEH的过滤表达式的函数中使用C++异常，当然最好的方式是将SEH转化为C++异常。通过调用_set_se_translator这个函数指定一个规定格式的回调函数指针就可以利用标准C++风格的关键字处理SEH了。下面是它们的定义：_set_se_translator(_se_translator_function seTransFunction); typedef void (*_se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS* );使用时,需要自定义实现_se_translator_function函数,在这个函数中通常可以通过throw一个C++异常的方式将捕获的SEH以标准C++EH的方式抛出下面是一个使用的例子：class SE_Exception { public: SE_Exception(){}; SE_Exception(DWORD dwErrCode) : dwExceptionCode(dwErrCode){}; ~SE_Exception(){}; private: DWORD dwExceptionCode; }; void STF(unsigned int ui, PEXCEPTION_POINTERS pEp) { printf("执行STF函数\n"); throw SE_Exception(); } void Func(int i) { int x = 0; int y = 5; x = y / i; } int _tmain(int argc, TCHAR *argv[]) { try { _set_se_translator(STF); Func(0); } catch(SE_Exception &e) { printf("main 函数中捕获到异常 \n"); } return 0; }程序首先调用_set_se_translator函数定义了一个回掉函数，当异常发生时，系统调用回掉函数，在函数中抛出一个自定义的异常类，在主函数中使用C++的异常处理捕获到了这个异常并成功输出了一条信息。

windows平台调用函数堆栈的追踪方法 在windows平台，有一个简单的方法来追踪调用函数的堆栈，就是利用函数CaptureStackBackTrace，但是这个函数不能得到具体调用函数的名称，只能得到地址，当然我们可以通过反汇编的方式通过地址得到函数的名称，以及具体调用的反汇编代码，但是对于有的时候我们需要直接得到函数的名称，这个时候据不能使用这个方法，对于这种需求我们可以使用函数：SymInitialize、StackWalk、SymGetSymFromAddr、SymGetLineFromAddr、SymCleanup。原理基本上所有高级语言都有专门为函数准备的堆栈，用来存储函数中定义的变量，在C/C++中在调用函数之前会保存当前函数的相关环境，在调用函数时首先进行参数压栈，然后call指令将当前eip的值压入堆栈中，然后调用函数，函数首先会将自身堆栈的栈底地址保存在ebp中，然后抬高esp并初始化本身的堆栈，通过多次调用最终在堆栈段形成这样的布局这里对函数的原理做简单的介绍，有兴趣的可以看我的另一篇关于C函数原理讲解的博客，点击这里跳转VC++编译器在编译时对函数名称与地址都有详细的记录，编译出来的程序都有一个符号常量表，将符号常量与它对应的地址形成映射，在搜索时首先根据这些堆栈环境找到对应地址，然后根据地址在符号常量表中，找到具体调用的信息，这是一个很复杂的工程，需要对编译原理和汇编有很强的基础，幸运的是，如今这些工作不需要程序员自己去做，windows帮助我们分配了一组API，在编写程序时只需要调用API即可函数说明SymInitialize：这个函数主要用作初始化相关环境。SymCleanup：清楚这个初始化的相关环境，在调用SymInitialize之后需要调用SymCleanup，进行释放资源的操作StackWalk：程序的功能主要由这个函数实现，函数会从初始化时的堆栈顶开始向下查找下一个堆栈的信息，原型如下：BOOL WINAPI StackWalk( __in DWORD MachineType, //机器类型现在一般是intel的x86系列，这个时候填入IMAGE_FILE_MACHINE_I386 __in HANDLE hProcess, //追踪的进程句柄 __in HANDLE hThread, //追踪的线程句柄 __in_out LPSTACKFRAME StackFrame, //记录的追踪到的堆栈信息 __in_out PVOID ContextRecord, //记录当前的线程环境 __in PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine, __in PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, __in PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, __in PTRANSLATE_ADDRESS_ROUTINE TranslateAddress //后面的四个参数都是回掉函数，有系统自行调用，而且这些函数都是定义好的，只需要填入相应的函数名称 );需要注意的一点是，在首次调用该函数时需要对StackFrame中的AddrPC、AddrFrame、AddrStack这三个成员进行初始化，填入相关值，以便函数从此处线程堆栈的栈顶进行搜索，否则调用函数将失败，具体如何填写请看MSDN。SymGetSymFromAddr：根据获取到的函数地址得到函数名称、堆栈大小等信息，这个函数的原型如下： BOOL WINAPI SymGetSymFromAddr( __in HANDLE hProcess, //进程句柄 __in DWORD Address, //函数地址 __out PDWORD Displacement, //返回该符号常量的位移或者填入NULL，不获取此值 __out PIMAGEHLP_SYMBOL Symbol//返回堆栈信息 );SymGetLineFromAddr：根据得到的地址值，获取调用函数的相关信息。主要记录是在哪个文件，哪行调用了该函数，下面是函数原型：BOOL WINAPI SymGetLineFromAddr( __in HANDLE hProcess, __in DWORD dwAddr, __out PDWORD pdwDisplacement, __out PIMAGEHLP_LINE Line );它参数的含义与SymGetSymFromAddr，相同。通过上面对函数的说明，我们可以知道，为了追踪函数调用的详细信息，大致步骤如下：首先调用函数SymInitialize进行相关的初始化工作。填充结构体StackFrame的相关信息，确定从何处开始追踪。循环调用StackWalk函数，从指定位置，向下一直追踪到最后。每次将获取的地址分别传入SymGetSymFromAddr、SymGetLineFromAddr，得到函数的详细信息调用SymCleanup，结束追踪但是需要注意的一点是，函数StackWalk会顺着线程堆栈进行查找，如果在调用之前，某个函数已经返回了，它的堆栈被回收，那么函数StackWalk自然不会追踪到该函数的调用。具体实现void InitTrack() { g_hHandle = GetCurrentProcess(); SymInitialize(g_hHandle, NULL, TRUE); } void StackTrack() { g_hThread = GetCurrentThread(); STACKFRAME sf = { 0 }; sf.AddrPC.Offset = g_context.Eip; sf.AddrPC.Mode = AddrModeFlat; sf.AddrFrame.Offset = g_context.Ebp; sf.AddrFrame.Mode = AddrModeFlat; sf.AddrStack.Offset = g_context.Esp; sf.AddrStack.Mode = AddrModeFlat; typedef struct tag_SYMBOL_INFO { IMAGEHLP_SYMBOL symInfo; TCHAR szBuffer[MAX_PATH]; } SYMBOL_INFO, *LPSYMBOL_INFO; DWORD dwDisplament = 0; SYMBOL_INFO stack_info = { 0 }; PIMAGEHLP_SYMBOL pSym = (PIMAGEHLP_SYMBOL)&stack_info; pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL); pSym->MaxNameLength = sizeof(SYMBOL_INFO) - offsetof(SYMBOL_INFO, symInfo.Name); IMAGEHLP_LINE ImageLine = { 0 }; ImageLine.SizeOfStruct = sizeof(IMAGEHLP_LINE); while (StackWalk(IMAGE_FILE_MACHINE_I386, g_hHandle, g_hThread, &sf, &g_context, NULL, SymFunctionTableAccess, SymGetModuleBase, NULL)) { SymGetSymFromAddr(g_hHandle, sf.AddrPC.Offset, &dwDisplament, pSym); SymGetLineFromAddr(g_hHandle, sf.AddrPC.Offset, &dwDisplament, &ImageLine); printf("当前调用函数 : %08x+%s(FILE[%s]LINE[%d])\n", pSym->Address, pSym->Name, ImageLine.FileName, ImageLine.LineNumber); } } void UninitTrack() { SymCleanup(g_hHandle); }测试程序如下：void func1() { OPEN_STACK_TRACK; } void func2() { func1(); } void func3() { func2(); } void func4() { printf("hello\n"); } int _tmain(int argc, TCHAR* argv[]) { func4(); func3(); func3(); return 0; }OPEN_STACK_TRACK是一个宏，它的定义如下：#define OPEN_STACK_TRACK\ HANDLE hThread = GetCurrentThread();\ GetThreadContext(hThread, &g_context);\ __asm{call $ + 5}\ __asm{pop eax}\ __asm{mov g_context.Eip, eax}\ __asm{mov g_context.Ebp, ebp}\ __asm{mov g_context.Esp, esp}\ InitTrack();\ StackTrack();\ UninitTrack();这个程序需要注意以下几点：如果想要追踪所有调用的函数，需要将这个宏放置到最后调用的位置，当然前提是此时之前被调函数的堆栈仍然存在。当然可以在调用前简单的计算，找出在哪个位置是所有函数都没有调用完成的，不过这样可能就与程序的初衷相悖，毕竟程序本身就是为了获取堆栈的调用信息。。。。IMAGEHLP_SYMBOL的结构体中关于Name的成员，只有一个字节，而函数SymGetSymFromAddr在填入值时是没有关心这个实际大小，它只是简单的填充，这就造成了缓冲区溢出的情况，为了避免我们需要在Name后面额外给一定大小的缓冲区，用来接收数据，这也就是我们定义这个结构体SYMBOL_INFO的原因。另外IMAGEHLP_SYMBOL中的MaxNameLength成员是指Name的最大长度，需要根据给定的缓冲区，进行计算。从测试程序来看，在进行追踪时func4已经调用完成，而我们在获取线程的运行时环境g_context时函数GetThreadContext，也在堆栈中，最终得到的结果中必然包含GetThreadContext的调用信息，如果想去掉这个信息，只需要修改获得信息的值，既然函数StackWalk是根据堆栈进行追踪，那么只需要修改对应堆栈的信息即可，需要修改eip 、ebp、esp的值，关于esp ebp的值很好修改，可以在对应函数中esp ebp这些寄存器的值，而eip的值就不那么好获取，本生利用mov指令得到eip的值它也是指令，会改变eip的值，从而造成获取到的eip的值不准确，所以我们利用call指令，先保存当前eip的值到堆栈，然后再从堆栈中取出。call指令的实质是 push eip和jmp addr指令的组合，并不一定非要调用函数。call指令的大小为5个字节，所以call $ + 5表示先保存eip在跳转到它的下一跳指令处。这样就可以有效的避免检测到GetThreadContext中的相关函数调用。

如何将VS 2015中的项目上传到github 最近开始慢慢接触github，现在希望将自己平时写的小程序，上传到github上，以便以后有个参考，在遇到同样问题的时候不至于想不起来怎么做而到处找别人的例子。VS 2015设置首先下载跟github相关的插件在弹出的对话框中选择联机，在右侧的搜索栏中输入关键字，搜索，下载对应的扩展程序重启后点击视图，选择团队资源管理器，选择连接管理在github官网创建代码仓库登陆github的官网，并创建一个代码仓库，记住该代码仓库的地址新建项目选择提交到git上后，在团队资源管理器中会显示这样的界面提交之后回到团队资源管理器的主页中，然后选择同步在地址栏中填入仓库的地址，并点击发布同步成功后，再次到新创建的代码仓库下，刷新一下，会发现这个时候项目已经上传上来了如果程序以后进行更新，那么只需要点击提交，然后填入提交的原因，注意因为上传时需要.opendb 和.db文件，而这个时候VS打开项目时又打开了这两个文件，所以上传会失败，需要在上传时忽略它们.上传它们后只需点击同步即可

windows错误处理 在调用windows API时函数会首先对我们传入的参数进行校验，然后执行，如果出现什么情况导致函数执行出错，有的函数可以通过返回值来判断函数是否出错，比如对于返回句柄的函数如果返回NULL 或者INVALID_HANDLE_VALUE，则函数出错，对于返回指针的函数来说如果返回NULL则函数出错，但是对于有的函数从返回值来看根本不知道是否成功，或者为什么失败，对此windows提供了一大堆的错误码，用于标识API函数是否出错以及出错原因。在windows中为每个线程准备了一个存储区，专门用来存储当前API执行的错误码，想要获取这个错误码可以通过函数GetLastError。在这需要注意的是当前API执行返回的错误码会覆盖之前API返回的错误码，所以在调用API结束后需要立马调用GetLastError来获取该函数返回的错误码。但是windows中的错误码实在太多，有的时候错误码并不直观，windows为每个错误码都关联了一个错误信息的文本，想要通过错误码获取对应的文本信息，可以通过函数FormatMessage来获取。下面是一个具体的例子：#include <windows.h> #include <tchar.h> #include <stdio.h> #include <strsafe.h> #define GRS_OUTPUT(s) WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), s, _tcsclen(s), NULL, NULL) int _tmain(int argc, TCHAR *argv[]) { if (INVALID_HANDLE_VALUE == CreateFile(_T("C:\\Test.txt"), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) { LPTSTR lpMsg = NULL; DWORD dwLastError = GetLastError(); FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError, GetUserDefaultLangID(), (LPTSTR)&lpMsg, 0, NULL); if (NULL != lpMsg) { TCHAR szErrorInfo[1024] = {0}; StringCchPrintf(szErrorInfo, sizeof(szErrorInfo), _T("打开文件失败，失败原因为:%s"), lpMsg); GRS_OUTPUT(szErrorInfo); HeapFree(GetProcessHeap(), 0, lpMsg); } } return 0; }在这段代码中我们没有使用C标准库中的printf，而是使用了windows自带的控制台函数WriteConsole，为了简单，我们定义了一个宏，用来输出字符串。函数WriteConsole的原型如下：BOOL WINAPI WriteConsole( __in HANDLE hConsoleOutput, __in const VOID* lpBuffer, __in DWORD nNumberOfCharsToWrite, __out LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved );函数的第一个参数是控制台的句柄，可以通过函数GetStdHandle来获取，这个函数主要传入一个标志，表示需要获取哪个控制台的句柄，主要有：STD_INPUT_HANDLE（标准输入）、STD_OUTPUT_HANDLE（标准输出）、STD_ERROR_HANDLE（标准错误）第二个参数是字符串的指针，第三个参数是字符个数，第四个参数是实际写入字符个数，由函数返回，如果不关心可以给NULL，最后一个windows作为保留参数通常给NULL。程序首先以打开已存在文件的方式打开一个文件，由于这个文件并不存在，所以函数出错，我们通过GetLastError获取错误码，然后通过FormatMessage来进行转化，该函数原型如下：DWORD FormatMessage( DWORD dwFlags, //标志 LPCVOID lpSource, //根据第一个参数的不同而有不同的解释 DWORD dwMessageId, //错误码 DWORD dwLanguageId, //语言ID LPTSTR lpBuffer, //字符缓冲区，用来存放最终生成的格式字符串 DWORD nSize, //缓冲区大小 va_list* Arguments//作为不定参数类似于printf函数格式化字符串后面的参数 ); 第一个参数是标志，在这我们传入FORMAT_MESSAGE_ALLOCATE_BUFFER，表示字符串缓冲区由该函数为我们分配，而不用自己分配，这个时候为了接受返回的字符缓冲区指针，需要使用二级指针。传入FORMAT_MESSAGE_IGNORE_INSERTS表示忽略插入的信息，也就是说不需要进行sprintf那样的格式化字符串的操作，传入FORMAT_MESSAGE_FROM_SYSTEM表示错误信息的字符串来自于系统定义的。然后进行简单的格式化之后输出错误字符串，最后需要释放内存，虽然FormatMessage函数帮我们分陪了缓冲，但是它不负责释放，需要我们自行释放。另外我们也可以自行进行错误码的设置，利用函数SetLastError可以达到这个效果，以模拟API调用时返回错误码的操作。在windows上一般遵循这样的格式：|位|31~30|29|28|27~16|15~0||:-|:----|:-|:-|:----|:---||用途|严重性|系统错误码|保留位|设备码|异常代码||含义|0 成功 <br/>1供参考<br/>2警告<br/>3错误|0系统定义<br/>1自定义|总为0|系统设备码|具体错误码|除了获取错误信息之外，还可以获取调用堆栈的快照，可以用函数CaptureStackBackTrace获取，只是这个函数只能获取调用堆栈的线性地址，不能获取到具体的函数名称。下面是它具体的一个例子： const int nCount = 128; PVOID BackTrace[nCount] = {NULL}; int iCnt = CaptureStackBackTrace(0, nCount, BackTrace, NULL); for (int i = 0; i < iCnt; i++) { printf("调用堆栈索引%d, 函数地址:0x%08x\n", i, BackTrace[i]); } return 0;这段代码非常简短，函数只需要四个参数，第一个参数是表示从当前栈顶开始的第几个栈开始便利，第二个参数是共便利多少个栈信息，第三个参数是一个缓冲区，用来存储得到的栈信息，具体就是栈的地址。第四个参数是一个哈希数组，由函数本身返回，如果不需要这个可以设置为NULL。

duilib基本框架 最近我一个同学在项目中使用到了duilib框架，但是之前并没有接触过，他与我讨论这方面的内容，看着官方给出的精美的例子，我对这个库有了很大的兴趣，我自己也是初学这个东东，我在网上花了不少时间来找相关的资料，但是找到的不多，官方给的文档又不全面，但是我还是找到了一些博主贡献的优秀的博文，现在我是通过博文上的讲解加上自己查看源代码的一些心得，正在艰难的前行。现在正在看的是博主Alberl在博客园中的duilib基础教程中的内容，下面的代码都是在他博客中给出代码的基础上做了一点小小的修改。点击这里跳转到对应的博客，以及博主夜雨無聲的博客，博客地址duilib的简介国内首个开源 的directui 界面库,它提供了一个所见即所得的开发工具——UIDesigner，它只有主框架窗口，其余的空间全部采用绘制的方式实现，所以对于控件来说没有句柄和窗口类等内容，它通过UIDesigner工具将用户定义的窗口保存在xml文件中，在创建窗口时读取xml文件中的内容，来绘制相应的控件。目前有许多界面采用duilib编写，大家可以去网上搜集相关资料。环境的配置首先我们去github上获取相关的源代码，这个是对应的项目地址：https://github.com/duilib/duilib下载完后，在目录中找到一个.sln结尾的文件，使用visual studio编译器打开，打开后发现有一个duilib的项目，以及其他，其实真正有用的就是这个duilib，其余的都是官方给出的例子代码。一般只需要编译这个duilib项目就可以了，当初没注意直接点了编译全部的，结果报了一堆错误，其实都是没有对应的lib和dll文件造成的。在VS环境下有一个编译选项，如下图所示上面有4个编译选项，最好将所有的都编译一遍，这样在对应项目的bin目录下会生成四个dll文件，这几个文件分别是debug下的UNICODE编码文件、ANSI文件以及Release版本下的UNICODE编码文件、ANSI文件。u代表unicode d代表debug。另外在lib目录下会生成对应的lib文件。在新建的工程中，点击属性在属性对话框中选择VC++目录，在源文件，库文件，包含文件中将对应的路径添加进去，分别是项目目录和lib文件目录。如下图（刚开始有点问题所以添加的内容有点多，但是不影响正常使用）：最后可以在环境变量的Path变量中添加对应的dll路径，这样就不需要将dll文件拷贝到自己项目的exe文件所在位置处。其实上述的环境可以不用设置，如果不设置，在编写程序包含相关路径时就需要给定完整的路径。到此处为止，整个开发环境就已经搭建好了，剩下的就是代码的编写了。基本的框架窗口首先新建一个Win32类型的项目，添加主函数。然后创建一个新类，我们叫做CDuiFrameWnd，下面是类的源代码//头文件 #include <DuiLib\UIlib.h> using namespace DuiLib; class CDuiFrameWnd : public CWindowWnd { public: CDuiFrameWnd(); ~CDuiFrameWnd(); virtual LPCTSTR GetWindowClassName() const; virtual LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam); protected: CPaintManagerUI m_PaintManager; };//cpp文件 LPCTSTR CDuiFrameWnd::GetWindowClassName() const { return _T("DuiFrameWnd"); } LRESULT CDuiFrameWnd::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT lRes = 0; if (WM_CLOSE == uMsg) { ::CloseWindow(m_hWnd); ::DestroyWindow(m_hWnd); } if (WM_DESTROY == uMsg) { ::PostQuitMessage(0); } return __super::HandleMessage(uMsg, wParam, lParam); }为了能够使用对应的dll文件，还需要引入对应的lib文件，我们在公共的头文件中加入如下代码#ifdef _DEBUG # ifdef _UNICODE # pragma comment(lib, "Duilib_ud.lib") # else # pragma comment(lib, "Duilib_d.lib") # endif #else # ifdef _UNICODE # pragma comment(lib, "Duilib_u.lib") # else # pragma comment(lib, "Duilib.lib") # endif #endif在主函数中的代码如下：int APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow) { CPaintManagerUI::SetInstance(hInstance); CDuiFrameWnd duiFrame; //#define UI_WNDSTYLE_FRAME (WS_VISIBLE | WS_OVERLAPPEDWINDOW) duiFrame.Create(NULL, _T("测试"), UI_WNDSTYLE_FRAME, WS_EX_WINDOWEDGE); duiFrame.ShowWindow(); CPaintManagerUI::MessageLoop(); return 0; }这些代码就可以帮助我们生成基本的框架窗口，另外我们需要时刻记住的是duilib是对win32 API的封装，所以可以直接使用win32的编程方式，如果以后有不会用的地方完全可以使用win32 的API来完成相关的功能的编写。框架的剖析既然它能够生成单文档的框架窗口，那么代码中所做的几步基本上与用纯粹的win32 API相同，所以我们沿着这个思路来进行框架的简单剖析。主函数中首先是代码CPaintManagerUI::SetInstance(hInstance);至于类CPaintManagerUI到底有什么作用，这个我也不太清楚，现在我还没有仔细看关于这个类的相关代码，这句话主要还是获取了进程的实例句柄。现在先不关心这个。下面的几步主要是在类CDuiFrameWnd中完成或者说在它的基类CWindowWnd中完成。创建窗口类主函数中的第二段代码主要完成的是类CDuiFrameWnd对象的创建，我们跟到对应的构造函数中发现它并没有做多余的操作，现在先不管它是如何构造的，它下面就是调用了类的Create函数创建了一个窗口，这个函数的代码如下：HWND CWindowWnd::Create(HWND hwndParent, LPCTSTR pstrName, DWORD dwStyle, DWORD dwExStyle, int x, int y, int cx, int cy, HMENU hMenu) { if( GetSuperClassName() != NULL && !RegisterSuperclass() ) return NULL; if( GetSuperClassName() == NULL && !RegisterWindowClass() ) return NULL; m_hWnd = ::CreateWindowEx(dwExStyle, GetWindowClassName(), pstrName, dwStyle, x, y, cx, cy, hwndParent, hMenu, CPaintManagerUI::GetInstance(), this); ASSERT(m_hWnd!=NULL); return m_hWnd; }我们主要来看第二个if中的代码，首先获得了父窗口的字符串为NULL，然后执行RegisterWindowClass，我们进一步跟到RegisterWindowClass中，它的代码如下：bool CWindowWnd::RegisterWindowClass() { WNDCLASS wc = { 0 }; wc.style = GetClassStyle(); wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hIcon = NULL; wc.lpfnWndProc = CWindowWnd::__WndProc; wc.hInstance = CPaintManagerUI::GetInstance(); //之前设置的实例句柄在这个地方使用 wc.hCursor = ::LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = GetWindowClassName(); ATOM ret = ::RegisterClass(&wc); ASSERT(ret!=NULL || ::GetLastError()==ERROR_CLASS_ALREADY_EXISTS); return ret != NULL || ::GetLastError() == ERROR_CLASS_ALREADY_EXISTS; }我们发现首先进行的是窗口类的创建，在创建窗口类时主要关心的是窗口类的lpfnWndProc成员和lpszClassName 。lpszClassName 调用了函数GetWindowClassName，这个函数我们在派生类中进行了重写，所以根据多态它会调用派生类的GetWindowClassName函数，将我们给定的字符串作为窗口类的类名注册窗口类从上面的代码可以看出注册的代码也是放在RegisterWindowClass中。在最后调用了RegisterClass函数完成了注册。创建窗口当RegisterWindowClass执行完成后，会接着执行下面的代码，也就是 m_hWnd = ::CreateWindowEx(dwExStyle, GetWindowClassName(), pstrName, dwStyle, x, y, cx, cy, hwndParent, hMenu, CPaintManagerUI::GetInstance(), this);完成创建窗口的任务。显示窗口Create函数执行完成后，会接着执行下面的duiFrame.ShowWindow();我们跟到这个函数中，函数代码如下：void CWindowWnd::ShowWindow(bool bShow /*= true*/, bool bTakeFocus /*= false*/) { ASSERT(::IsWindow(m_hWnd)); if( !::IsWindow(m_hWnd) ) return; ::ShowWindow(m_hWnd, bShow ? (bTakeFocus ? SW_SHOWNORMAL : SW_SHOWNOACTIVATE) : SW_HIDE); }函数ShowWindow默认传入参数为bShow = true bTakeFocus = false；在最后进行ShowWindow函数的调用时，根据bShow和bTakeFocus来进行值得传入，根据代码我们发现，当不传入参数时调用的其实是这样的代码ShowWindow(m_hWnd, SW_SHOWNOACTIVATE);消息循环消息循环其实是通过代码CPaintManagerUI::MessageLoop();完成，我们跟到MessageLoop函数中看 MSG msg = { 0 }; while( ::GetMessage(&msg, NULL, 0, 0) ) { if( !CPaintManagerUI::TranslateMessage(&msg) ) { ::TranslateMessage(&msg); ::DispatchMessage(&msg); } }在这个函数中完成了消息循环。回调函数上面我们留了一个lpfnWndProc函数指针没有说，现在来说明这个部分，跟进到对应的构造函数中，发现类本身不做任何操作，但是父类的构造函数进行了相关的初始化操作，下面是对应的代码CWindowWnd::CWindowWnd() : m_hWnd(NULL), m_OldWndProc(::DefWindowProc), m_bSubclassed(false) { }这样就将lpfnWndProc指向了__WndProc，用于处理默认的消息。这是一个静态的处理函数，下面是它的代码：LRESULT CALLBACK CWindowWnd::__WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CWindowWnd* pThis = NULL; if( uMsg == WM_NCCREATE ) { LPCREATESTRUCT lpcs = reinterpret_cast<LPCREATESTRUCT>(lParam); pThis = static_cast<CWindowWnd*>(lpcs->lpCreateParams); pThis->m_hWnd = hWnd; //当开始创建窗口将窗口类对象的指针放入到对应的GWLP_USERDATA字段中 ::SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LPARAM>(pThis)); } else { //取出窗口类对象的指针 pThis = reinterpret_cast<CWindowWnd*>(::GetWindowLongPtr(hWnd, GWLP_USERDATA)); if( uMsg == WM_NCDESTROY && pThis != NULL ) { LRESULT lRes = ::CallWindowProc(pThis->m_OldWndProc, hWnd, uMsg, wParam, lParam); ::SetWindowLongPtr(pThis->m_hWnd, GWLP_USERDATA, 0L); if( pThis->m_bSubclassed ) pThis->Unsubclass(); pThis->m_hWnd = NULL; pThis->OnFinalMessage(hWnd); return lRes; } } if( pThis != NULL ) { return pThis->HandleMessage(uMsg, wParam, lParam); } else { return ::DefWindowProc(hWnd, uMsg, wParam, lParam); } }上述的代码，在创建窗口时将窗口类对象指针存入到对应的位置便于在其他位置取出并使用。通过return pThis->HandleMessage(uMsg, wParam, lParam);这句话调用的具体对象的HandleMessage，我们在对应的派生类中定义了相应的虚函数，所以根据多态它会调用我们重写的虚函数来处理具体消息，至于我们不关心的消息，它会调用LRESULT lRes = ::CallWindowProc(pThis->m_OldWndProc, hWnd, uMsg, wParam, lParam);或者DefWindowProc，通过对基类的构造函数的查看，我们发现其实m_OldWndProc就是DefWindowProc。总结上面我们说明了duilib的基本框架，下面来总结一下：CPaintManagerUI::SetInstance(hInstance);设置进程的实例句柄，这个值会在注册窗口类时使用在CWindowWnd类中由Create函数完成窗口类的创建于注册，以及窗口的创建工作CWindowWnd类中的ShowWindow函数用于显示窗口消息循环由CPaintManagerUI::MessageLoop();代码完成最后需要重写MessageHandle函数用于处理我们感兴趣的消息。并且在最后需要调用基类的MessageHandle函数，主要是为了调用DefWindowProc处理我们不感兴趣的消息。

Windows平台下的内存泄漏检测 在C/C++中内存泄漏是一个不可避免的问题，很多新手甚至有许多老手也会犯这样的错误，下面说明一下在windows平台下如何检测内存泄漏。在windows平台下内存泄漏检测的原理大致如下。在分配内存的同时将内存块的信息保存到相应的结构中，标识为已分配当内存释放时在结构中查找，并将相应的标识设置为已释放在需要的位置调用HeapWalk，遍历整个堆内存，找到对应的内存块的首地址，并与定义的结构中的数据相匹配，根据结构中的标识判断是否释放，未释放的话给出相应的提示信息。另外在VS系列的编译器中如果输出的调试信息的格式为：文件名（行号）双击这样的输出信息，会自动跳转到对应的位置，利用这点可以很容易的定位到未释放的内存的位置。为了实现上述功能，我们使用重载new和delete的方式。下面是具体的代码：#define MAX_BUFFER_SIZE 1000 typedef struct tag_ST_BLOCK_INFO { TCHAR m_szSourcePath[MAX_PATH]; INT m_iLine; BOOL m_bDelete; void *pBlock; }ST_BLOCK_INFO, *LP_ST_BLOCK_INFO; class CMemoryLeak { public: CMemoryLeak(void); ~CMemoryLeak(void); void MemoryLeak(); void add(LPCTSTR m_szSourcePath, INT m_iLine, void *pBlock); int GetLength(); ST_BLOCK_INFO& operator [](int nSite); protected: HANDLE m_heap;//自定义堆 LP_ST_BLOCK_INFO m_pBlockInfo; int m_BlockSize; //当前缓冲区大小 int m_hasInfo;//当前记录了多少值 };CMemoryLeak::CMemoryLeak(void) { if (m_heap == NULL) { //打开异常检测 m_heap = HeapCreate(HEAP_GENERATE_EXCEPTIONS,0,0); ULONG HeapFragValue = 2; //允许系统记录堆内存的使用 HeapSetInformation( m_heap,HeapCompatibilityInformation,&HeapFragValue ,sizeof(HeapFragValue)) ; } if (NULL == m_pBlockInfo) { m_pBlockInfo = (LP_ST_BLOCK_INFO)HeapAlloc(m_heap, HEAP_ZERO_MEMORY, MAX_BUFFER_SIZE * sizeof(ST_BLOCK_INFO)); m_BlockSize = MAX_BUFFER_SIZE; m_hasInfo = 0; } } void CMemoryLeak::add(LPCTSTR m_szSourcePath, INT m_iLine, void *pBlock) { //当前缓冲区已满 if (m_hasInfo >= m_BlockSize) { //扩大缓冲区容量 HeapReAlloc(m_heap, HEAP_ZERO_MEMORY, m_pBlockInfo, m_BlockSize * 2 * sizeof(ST_BLOCK_INFO)); m_BlockSize *= 2; } m_pBlockInfo[m_hasInfo].m_bDelete = FALSE; m_pBlockInfo[m_hasInfo].m_iLine = m_iLine; _tcscpy(m_pBlockInfo[m_hasInfo].m_szSourcePath, m_szSourcePath); m_pBlockInfo[m_hasInfo].pBlock = pBlock; m_hasInfo++; } CMemoryLeak::~CMemoryLeak(void) { HeapFree(m_heap, 0, m_pBlockInfo); HeapDestroy(m_heap); } void CMemoryLeak::MemoryLeak() { TCHAR pszOutPutInfo[2*MAX_PATH]; //调试字符串 BOOL bRecord = FALSE; //当前内存是否被记录 PROCESS_HEAP_ENTRY phe = {}; HeapLock(GetProcessHeap()); //检测时锁定堆防止对堆内存进行写入 OutputDebugString(_T("开始检查内存泄露情况.........\n")); while (HeapWalk(GetProcessHeap(), &phe)) { //当这块内存正在使用时 if( PROCESS_HEAP_ENTRY_BUSY & phe.wFlags ) { bRecord = FALSE; for(UINT i = 0; i < m_hasInfo; i ++ ) { if( phe.lpData == m_pBlockInfo[i].pBlock) { //校验这块内存是否被释放 if(!m_pBlockInfo[i].m_bDelete) { StringCchPrintf(pszOutPutInfo,2*MAX_PATH,_T("%s(%d):内存块(Point=0x%08X,Size=%u)\n") ,m_pBlockInfo[i].m_szSourcePath,m_pBlockInfo[i].m_iLine,phe.lpData,phe.cbData); OutputDebugString(pszOutPutInfo); } bRecord = TRUE; break; } } if( !bRecord ) { StringCchPrintf(pszOutPutInfo,2*MAX_PATH,_T("未记录的内存块(Point=0x%08X,Size=%u)\n") ,phe.lpData,phe.cbData); OutputDebugString(pszOutPutInfo); } } } HeapUnlock(GetProcessHeap()); OutputDebugString(_T("内存泄露检查完毕.\n")); } int CMemoryLeak::GetLength() { return m_hasInfo; } ST_BLOCK_INFO& CMemoryLeak::operator [](int nSite) { return m_pBlockInfo[nSite]; } CMemoryLeak g_MemoryLeak; void* __cdecl operator new(size_t nSize,LPCTSTR pszCppFile,int iLine) { //在分配内存的时候将这块内存信息记录到相应的结构中 void *p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize); g_MemoryLeak.add(pszCppFile, iLine, p); return p; } void __cdecl operator delete(void *p, TCHAR *pstrPath, int nLine) { ::operator delete(p); HeapFree(GetProcessHeap(), 0, p); } void __cdecl operator delete(void* p) { //依次遍历结构体数组，找到对应内存块的记录，将标志设置为已删除 for (int i = 0; i < g_MemoryLeak.GetLength(); i++) { if (p == g_MemoryLeak[i].pBlock) { g_MemoryLeak[i].m_bDelete = TRUE; } } HeapFree(GetProcessHeap(), 0, p); }下面是一个测试的例子#ifdef _UNICODE //将__FILE__转化为对应的UNICODE版本 #define GRS_WIDEN2(x) L ## x #define GRS_WIDEN(x) GRS_WIDEN2(x) #define __WFILE__ GRS_WIDEN(__FILE__) //这段代码不能与重载的申明在同一个头文件下，否则在编译时会将定义的new函数进行替换 #define new new(__WFILE__,__LINE__) #define delete(p) ::operator delete(p,__WFILE__,__LINE__) #else #define new new(__FILE__,__LINE__) #define delete(p) ::operator delete(p,__FILE__,__LINE__) #endif int _tmain() { int* pInt1 = new int; int* pInt2 = new int; float* pFloat1 = new float; BYTE* pBt = new BYTE[100]; delete[] pBt; //在DEBUG环境下启用检测 #ifdef _DEBUG g_MemoryLeak.MemoryLeak(); #endif return 0; }上面的代码中，定义了一个结构体 ST_BLOCK_INFO来保存每个分配的内存块的信息，同时采用数组的方式来保存多个内存块的信息，为了便于管理这些信息，专门定义了一个类来操作这个数组，类中记录了数组的首地址，当前保存的信息总量和当前能够容纳的信息总量，同时这个数组支持动态扩展。在遍历时利用HeapWalk函数遍历系统默认堆中的所有内存，找到正在使用的内存，并在结构数组中查找判断内存是否被释放，如果未背释放则输出调试信息。在主函数中利用宏定义的方式，使程序只在debug环境下来校验内存泄漏，方便调试同时在发行时不会拖累程序运行。最后对程序再做最后几点说明：动态数组不要使用new 和delete来分配和释放空间，因为我们重载了这两个函数，这样在检测的时候会有一定的影响new本身的定义如下: void* operator new(size_t size) throw(std::bad_alloc)平时在使用上例如void p = new int 其实等于void p = new(sizeof(int)),同时如果使用void p = new int[10] 等于 void p = new(sizeof(int) 10) 上面定义的#define new new(__WFILE__,__LINE__) 其实在调用时相当于void p = new(__WFILE__,__LINE__) int,也就是等于void *p = new(sizeof(int), __WFILE__,__LINE__)当然delete也是同理在申请数组空间时不要使用系统默认的堆，因为重载new和delete使用的就是系统默认堆，检测的也是默认堆，如果用默认堆来保存数组数据，会对结果产生影响。当然用这样的方式写有点浪费内存资源，如果一个程序需要new出大量的数据，那么需要的额外内存也太多，所以可以使用链表来保存，当调用delete时将结点从链表中删除，这样只要链表中存在的都是未被删除的；或者使用数组，当有一个被删除，将这个位置的索引用队列的方式记录下来，每当要新增数组数据时根据队列中保存的索引找到对应的位置进行覆盖操作。这样可以节省一定的空间。

windows PAE扩展和AWE编程 在32位windows上只能看到最大3GB的内存空间，而且每个应用程序只能访问4GB的的内存，这个限制是windows独有的，为了使程序能够访问大于4GB的内存空间，需要使用AWE编程接口，同时需要开启PAE，让系统支持大于3GB的内存，开启PAE最大能支持128GB的内存。PAE开启在windows 7及以上的系统主要使用BCDEdit命令而XP系统使用的是修改boot.ini文件的方式，下面主要介绍的是windows 7 上开启PAE的方式在命令行下输入BCDEdit /set PAE forceenable windows另外如果需要扩大用户分区可以打开/3GB开关，这个开关在windows 7上用命令：BCDEdit /set IncreaseUseVa 3072(后面的数字代表的是用户分区的大小，3072正是3GB)另外编译选项需要打开/LARGEADDRESSAWARE开关AWE编程接口开启PAE之后想要自己的程序能够访问到超过4GB的内存，需要使用AWE的编程接口，AWE(Address Windowing Extensions)是地址窗口扩展。使用AWE时,所有物理页面的交换控制就由应用程序自己控制使用的基本步骤:使用VirtualAlloc + MEM_PHYSICAL分配保留一段地址空间准备用于存储页表的数组申请分配物理内存(AllocateUserPhysicalPages)将物理内存映射到“窗口”中(MapUserPhysicalPages)对映射的内存进行读写操作释放物理内存页面(FreeUserPhysicalPages)释放对应的保留地址空间下面是使用AWE的简单例子#define MEMORY_REQUESTED 1024 * 1024 * 1024 //1GB BOOL bResult; // generic Boolean value ULONG_PTR NumberOfPages; // number of pages to request ULONG_PTR NumberOfPagesInitial; // initial number of pages requested ULONG_PTR *aPFNs1; // page info; holds opaque data ULONG_PTR *aPFNs2; // page info; holds opaque data PVOID lpMemReserved; // AWE window SYSTEM_INFO sSysInfo; // useful system information int PFNArraySize; // memory to request for PFN array TCHAR* pszData; TCHAR pszReadData[100]; MEMORYSTATUSEX ms = {sizeof(MEMORYSTATUSEX)}; GlobalMemoryStatusEx(&ms); //使用VirtualAlloc + MEM_PHYSICAL分配保留一段地址空间 lpMemReserved = VirtualAlloc( NULL,MEMORY_REQUESTED, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE ); //计算需要的物理页面大小 以及物理页面需要的页表数组大小 GetSystemInfo(&sSysInfo); // fill the system information structure //向上取整，计算出需要多少个页表项 NumberOfPages = (MEMORY_REQUESTED + sSysInfo.dwPageSize - 1)/sSysInfo.dwPageSize; PFNArraySize = NumberOfPages * sizeof (ULONG_PTR); //2 准备物理页面的页表数组数据 aPFNs1 = (ULONG_PTR *) HeapAlloc(GetProcessHeap(), 0, PFNArraySize); aPFNs2 = (ULONG_PTR *) HeapAlloc(GetProcessHeap(), 0, PFNArraySize); NumberOfPagesInitial = NumberOfPages; //3 分配物理页面 bResult = AllocateUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs1 ); bResult = AllocateUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs2 ); //4 映射第一个1GB到保留的空间中 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,aPFNs1 ); pszData = (TCHAR*)lpMemReserved; _tcscpy(pszData,_T("这是第一块物理内存")); //5 映射第二个1GB到保留的空间中 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,aPFNs2 ); _tcscpy(pszData,_T("这是第二块物理内存")); //6 再映射回第一块内存,并读取开始部分 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,aPFNs1 ); _tcscpy(pszReadData,pszData); //7 取消映射 bResult = MapUserPhysicalPages( lpMemReserved,NumberOfPages,NULL ); //8 释放物理页面 bResult = FreeUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs1 ); bResult = FreeUserPhysicalPages( GetCurrentProcess(),&NumberOfPages,aPFNs2 ); //9 释放保留的"窗口"空间 bResult = VirtualFree( lpMemReserved,0, MEM_RELEASE ); //10 释放页表数组 bResult = HeapFree(GetProcessHeap(), 0, aPFNs1); bResult = HeapFree(GetProcessHeap(), 0, aPFNs2); _tsystem(_T("PAUSE"));上述代码中，虽然只保留了1GB的虚拟地址空间，但是这1GB的虚拟地址空间通过映射的方式，映射到具体不同的真实内存中，这个就是PAE能访问大于4GB内存的秘密，通过对分页机制的了解，4字节的虚拟地址空间能够映射4KB的一页内存，所以经过简单的计算，其实没多映射1GB的内存其实只需要1M的数组来存储这些页表项。64位的windows不再也没有必要支持AWE技术，因为这个技术就是为了解决应用程序访问内存不足的情况，但是在64位系统中不存在这个问题，也许有朝一日64位的操作系统也会出现能够访问的内存太少的情况，这个时候说不定会出现类似于AWE的技术