Windows系统线程池+利用windows自带的线程池

最新推荐文章于 2024-01-13 12:45:48 发布

werben

最新推荐文章于 2024-01-13 12:45:48 发布

阅读量5k

点赞数 1

分类专栏：服务器 C++

C++ 同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

服务器

12 篇文章 0 订阅

订阅专栏

come from:http://www.fuzhijie.me/?p=65
一直想弄明白Windows的IO完成端口是什么，这个词语每每出现在我眼前时总是伴随着鲜花和赞美，因此我便将其同许多我从来没搞懂过的东西一起归为神秘一类。这两天一直在看《Windows核心编程》，学到了不少东西，但是同别的英文经典一样，中文版经常让我感觉不知所云，我很不喜欢书中的例子都是用C++来写，并且都有图形界面，这阻碍了初学者理解问题的本质，并不是每个人都熟悉Windows的图形界面编程，Windows的API不仅个数多，许多API参数也非常多，如果仅仅是简单类型也就罢了，许多参数又会是复杂的结构体，相比之下，Unix的系统调用就简洁多了。我打算循序渐进，先学习了下Windows自带的线程池的使用，这个东西实现得挺好的，Linux没有提供等同物。

MSDN中对线程池的使用只给出了一个实例，相关的代码网上少得可怜，我只能对这例子视若珍宝，好好研究了一番，去掉一些旁枝末节，添加点注释吧，就当作是读书札记吧。

《Windows核心编程》中将线程池允许我们做的事情归为四类，分别如下：
情景1：以异步方式调用函数
情景2：每隔一段时间调用一个函数
情景3：在内核对象触发时调用一个函数
情景4：在异步I/O请求完成时调用一个函数

MSDN中的这个例子演示了前三种情景，这三种情景下的回调函数的签名各不一样。原程序中没有给清理组设置回调函数，我写了一个清理回调函数，也只是简单地打印出运行代码的线程号等信息而已。

[cpp]view plaincopy 
    
 //  
 // Thread pool wait callback function template  
 //  
 //  
 //注意这三种回调函数的签名，它们都没有返回值  
 VOID  
 CALLBACK  
 MyWaitCallback(  
       PTP_CALLBACK_INSTANCE Instance,  
       PVOID                 Parameter,  
       PTP_WAIT              Wait,  
       TP_WAIT_RESULT        WaitResult  
       )  
 {  
     printf("%u in MyWaitCallback\n", GetCurrentThreadId());  
 }  
    
 //  
 // Thread pool timer callback function template  
 //  
 VOID  
 CALLBACK  
 MyTimerCallback(  
     PTP_CALLBACK_INSTANCE Instance,  
     PVOID                 Parameter,  
     PTP_TIMER             Timer  
     )  
 {  
     printf("(%u) in MyTimerCallback\n", GetCurrentThreadId());  
 }  
    
 //  
 // This is the thread pool work callback function.  
 // The callback demonstrates correct behavior when changing the  
 // state of the thread inside the callback function.  
 //  
 // Any changes to the thread state must be restored to original  
 // before exiting the callback routine.  
 //  
 VOID  
 CALLBACK  
 MyWorkCallback(  
       PTP_CALLBACK_INSTANCE Instance,  
       PVOID                 Parameter,  
       PTP_WORK              Work  
       )  
 {  
     printf("(%u) in MyWorkCallback\n", GetCurrentThreadId());  
 }  
    
 VOID  
 CALLBACK  
 MyCleanupCallback(  
       PVOID pvObjectContext,  
       PVOID pvCleanupContext  
       )  
 {  
     printf("(%u) in MyCleanupCallback\n", GetCurrentThreadId());  
 }  
    
 VOID  
 DemoCleanupPersistentWorkTimer()  
 {  
     BOOL bRet = FALSE;  
     PTP_WORK work = NULL;  
     PTP_TIMER timer = NULL;  
     PTP_POOL pool = NULL;  
     TP_CALLBACK_ENVIRON CallBackEnviron;  
     PTP_CLEANUP_GROUP cleanupgroup = NULL;  
     FILETIME FileDueTime;  
     ULARGE_INTEGER ulDueTime;  
     UINT rollback = 0;  
    
     printf("(%u)in DemoCleanupPersistentWorkTimer\n", GetCurrentThreadId());  
    
     //初始化很重要，否则运行到CreateThreadpoolWork将会出错  
     //可以在调试模式下看看TP_CALLBACK_ENVIRON结构体的内容  
     InitializeThreadpoolEnvironment(&CallBackEnviron);  
    
     //  
     // Create a custom, dedicated thread pool  
     //  
     pool = CreateThreadpool(NULL);  
    
     if (NULL == pool) {  
         _tprintf(_T("CreateThreadpool failed. LastError: %u\n"),  
         GetLastError());  
         goto main_cleanup;  
     }  
    
     rollback = 1; // pool creation succeeded  
    
     //  
     // The thread pool is made persistent simply by setting  
     // both the minimum and maximum threads to 1.  
     //  
     //将最大值和最小值都设置为1，若提交几个工作项时，所有的工作项都由这一个线程完成  
     //如果可以开启多个线程，可以看到会有好几个线程一起来完成这些工作项  
     SetThreadpoolThreadMaximum(pool, 1);  
    
     bRet = SetThreadpoolThreadMinimum(pool, 4);  
    
     if (FALSE == bRet) {  
         _tprintf(_T("SetThreadpoolThreadMinimum failed. LastError: %u\n"), GetLastError());  
         goto main_cleanup;  
     }  
    
     //  
     // Create a cleanup group for this thread pool  
     //  
     cleanupgroup = CreateThreadpoolCleanupGroup();  
    
     if (NULL == cleanupgroup) {  
         _tprintf(_T("CreateThreadpoolCleanupGroup failed. LastError: %u\n"), GetLastError());  
         goto main_cleanup;  
     }  
    
     rollback = 2;  // Cleanup group creation succeeded  
    
     //  
     // Associate the callback environment with our thread pool  
     //  
     SetThreadpoolCallbackPool(&CallBackEnviron, pool);  
    
     //  
     // Associate the cleanup group with our thread pool  
     //  
     SetThreadpoolCallbackCleanupGroup(&CallBackEnviron,  
         cleanupgroup,  
         &MyCleanupCallback);  
    
     //  
     // Create work with the callback environment  
     //  
     //使用的线程池被包含在CallBackEnviron参数中  
     //如果此处传递NULL进去，将使用一个默认的线程池  
     work = CreateThreadpoolWork((PTP_WORK_CALLBACK) MyWorkCallback,  
         NULL,  
         &CallBackEnviron);  
    
     if (NULL == work) {  
         _tprintf(_T("CreateThreadpoolWork failed. LastError: %u\n"),  
         GetLastError());  
         goto main_cleanup;  
     }  
    
     rollback = 3;  // Creation of work succeeded  
    
     //  
     // Submit the work to the pool. Because this was a pre-allocated  
     // work item (using CreateThreadpoolWork), it is guaranteed  
     // to execute  
     //  
     //可以多提交几个工作项试试看，  
     SubmitThreadpoolWork(work);  
     SubmitThreadpoolWork(work);  
     SubmitThreadpoolWork(work);  
     SubmitThreadpoolWork(work);  
    
     //  
     // Create a timer with the same callback environment  
     //  
     timer = CreateThreadpoolTimer(  
         (PTP_TIMER_CALLBACK) MyTimerCallback,  
         NULL, &CallBackEnviron);  
    
     if (NULL == timer) {  
         _tprintf(_T("CreateThreadpoolTimer failed. LastError: %u\n"),  
         GetLastError());  
         goto main_cleanup;  
     }  
    
     rollback = 4;  // Timer creation succeeded  
    
     //  
     // Set the timer to fire in one second  
     //  
     //如果为正值，则表示绝对时间，从1600年1月1日开始计算，单位为纳秒  
     //如果为负值，则表示相对时间，单位为微秒  
     //两种情况下单位不一样哦。  
     ulDueTime.QuadPart = (LONGLONG) -(100000000);  
     FileDueTime.dwHighDateTime = ulDueTime.HighPart;  
     FileDueTime.dwLowDateTime  = ulDueTime.LowPart;  
    
     //定时器只触发一次  
     SetThreadpoolTimer(timer,  
         &FileDueTime,  
         0,  
         0);  
    
     //  
     // Delay for the timer to be fired  
     //  
     //等待线程池中的线程完成定时器中的工作，注意这儿睡眠的值  
     //要大于上面定时器触发的值，否则就看不到结果了。  
     Sleep(15000);  
    
     //  
     // Wait for all callbacks to finish.  
     // CloseThreadpoolCleanupGroupMembers also calls the cleanup  
     // functions for all the individual objects in the specified  
     // cleanup group.  
     //  
     //此时主线程会调用MyCleanupCallback两次，我还没怎么明白清理组的使用方法  
     CloseThreadpoolCleanupGroupMembers(cleanupgroup,  
         FALSE,  
         NULL);  
    
     //  
     // Already cleaned up the work item with the  
     // CloseThreadpoolCleanupGroupMembers, so set rollback to 2.  
     //  
     rollback = 2;  
     goto main_cleanup;  
    
 main_cleanup:  
     //  
     // Clean up any individual pieces manually  
     // Notice the fall through structure of the switch.  
     // Clean up in reverse order.  
     //  
    
     switch (rollback) {  
         case 4:  
         case 3:  
             // Clean up the cleanup group members  
             CloseThreadpoolCleanupGroupMembers(cleanupgroup,  
             FALSE, NULL);  
         case 2:  
             // Clean up the cleanup group  
             CloseThreadpoolCleanupGroup(cleanupgroup);  
    
         case 1:  
             // Clean up the pool  
             CloseThreadpool(pool);  
    
         default:  
             break;  
     }  
    
     return;  
 }  
    
 VOID  
 DemoNewRegisterWait()  
 {  
     PTP_WAIT Wait = NULL;  
     HANDLE hEvent = NULL;  
     UINT i = 0;  
     UINT rollback = 0;  
    
     printf("(%u)in DemoNewRegisterWait\n", GetCurrentThreadId());  
    
     //  
     // Create an auto-reset event  
     //  
     hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);  
    
     if (NULL == hEvent) {  
         // Error Handling  
         return;  
     }  
    
     rollback = 1; // CreateEvent succeeded  
    
     Wait = CreateThreadpoolWait((PTP_WAIT_CALLBACK) MyWaitCallback,  
         NULL,  
         NULL);  
    
     if(NULL == Wait) {  
         _tprintf(_T("CreateThreadpoolWait failed. LastError: %u\n"),  
         GetLastError());  
         goto new_wait_cleanup;  
     }  
    
     rollback = 2; // CreateThreadpoolWait succeeded  
    
     //  
     // Need to re-register the event with the wait object  
     // each time before signaling the event to trigger the  
     // wait callback  
     //  
     for (i = 0; i < 5; i ++) {  
         SetThreadpoolWait(Wait,  
         hEvent,  
         NULL);  
    
         //将事业设置成触发态  
         SetEvent(hEvent);  
    
         //  
         // Delay for the waiter thread to act if necessary  
         //  
         Sleep(500);  
    
         //  
         // Block here until the callback function is done executing  
         //  
         //等待回调函数执行完  
         WaitForThreadpoolWaitCallbacks(Wait, FALSE);  
     }  
    
 new_wait_cleanup:  
     switch (rollback) {  
         case 2:  
             // Unregister the wait by setting the event to NULL  
             SetThreadpoolWait(Wait, NULL, NULL);  
    
             // Close wait  
             CloseThreadpoolWait(Wait);  
    
         case 1:  
             // Close event  
             CloseHandle(hEvent);  
    
         default:  
         break;  
     }  
     return;  
 }  
    
 int main()  
 {  
     DemoCleanupPersistentWorkTimer();  
    
     DemoNewRegisterWait();  
    
     return 0;  
 }  

werben

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Windows系统线程池+利用windows自带的线程池

come from:http://www.fuzhijie.me/?p=65一直想弄明白Windows的IO完成端口是什么，这个词语每每出现在我眼前时总是伴随着鲜花和赞美，因此我便将其同许多我从来没搞懂过的东西一起归为神秘一类。这两天一直在看《Windows核心编程》，学到了不少东西，但是同别的英文经典一样，中文版经常让我感觉不知所云，我很不喜欢书中的例子都是用C++来写，并且都有图形界面，这
复制链接

扫一扫