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

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

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

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

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

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