windows线程池四种情形（win核心读书笔记）

徐冬丽

windows线程池四种情形（win核心读书笔记）
　　Mircosoft从Windows2000引入线程池API，并在Vista后对线程池重新构架，引入新的线程池API。以下所有线程池函数均适用于Vista以后的版本。
　　用Windows提供的线程池函数有以下几个好处：1，不必要用CreateThread创建线程；2，不必要管理自己线程；3，Windows封装好的线程池，效率高，性能优越。

1　　异步方式调用函数
　　这种方式和我们用CreateThread创建线程的用法差不多，给定一个线程函数模板实现功能，然后API去调用这些线程函数。简单的线程函数模板如下：



VOID CALLBACK SimpleCallback(
   [in, out]            PTP_CALLBACK_INSTANCE Instance,
   [in, out, optional]  PVOID Context
);
　　第一个参数暂不解释，第二个参数是传给毁掉函数的任意值。
　　对应的线程池API函数为TrySubmitThreadpoolCallback，函数定义如下：



BOOL WINAPI TrySubmitThreadpoolCallback(
   __in          PTP_SIMPLE_CALLBACK pfns,
   __in_out_opt  PVOID pv,
   __in_opt      PTP_CALLBACK_ENVIRON pcbe
);
　　第一个参数是线程函数，第二个参数是给线程函数传的值（Context），第三个参数用作对线程池定制。返回值为TRUE表示线程后续将启动，FALSE表示调用失败。一个小例子为：



VOID NTAPI WorkThread(PTP_CALLBACK_INSTANCE Instance,PVOID Context)
{
     AfxMessageBox(_T("this is a workthread"));
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
     ...

     if (TrySubmitThreadpoolCallback(WorkThread,NULL,NULL))
     {
         AfxMessageBox(_T("TRUE"));
     }
     else
     {
         AfxMessageBox(_T("FALSE"));
     }
     ...
}
　　利用TrySubmitThreadpoolCallback函数有可能失败，这时线程将不会启动。为了确保线程能够启动过，必须显示创建一个工作项对象，知道把工作项提交到线程池中。创建工作项函数如下：



PTP_WORK WINAPI CreateThreadpoolWork(
   __in          PTP_WORK_CALLBACK pfnwk,
   __in_out_opt  PVOID pv,
   __in_opt      PTP_CALLBACK_ENVIRON pcbe
);
　　第一个参数是线程函数，第二个参数是给线程函数传的值（Context），第三个参数用作对线程池定制。这个函数使用的县曾函数模板是：



VOID CALLBACK WorkCallback(
   [in, out]            PTP_CALLBACK_INSTANCE Instance,
   [in, out, optional]  PVOID Context,
   [in, out]            PTP_WORK Work
);
　　创建工作项后，需要提交工作项给线程池，让线程池分配线程处理该项。提交工作项请求的函数是SubmitThreadpoolWork，定义如下：



VOID WINAPI SubmitThreadpoolWork(
   __in_out      PTP_WORK pwk
);
　　等待工作项完成的函数是WaitForThreadpoolWorkCallbacks，定义如下：



VOID WINAPI WaitForThreadpoolWorkCallbacks(
   __in_out      PTP_WORK pwk,
   __in          BOOL fCancelPendingCallbacks
);
　　该函数的第二个参数，如果传值为TRUE，试图取消提交的工作项。如果工作项已启动，则等待；FALSE，当前线程挂起，直到工作项完成。
　　取消工作项的函数是CloseThreadpoolWork，定义如下：



VOID WINAPI CloseThreadpoolWork(
   __in_out      PTP_WORK pwk
);
　　一个简单的例子为：



VOID CALLBACK WorkThread1(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PTP_WORK Work)
{
     for (int i=0;i<5;i++)
     {
         AfxMessageBox(_T("this is a WorkCallback fun"));
         Sleep(1000);
     }
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
     ...
     PTP_WORK pw = CreateThreadpoolWork(WorkThread1,NULL,NULL);
     SubmitThreadpoolWork(pw);
     //给线程足够多的时间启动
     Sleep(2000);
     //TRUE，试图取消提交的工作项。如果工作项已启动，则等待；
     //FALSE，当前线程挂起，直到工作项完成
     WaitForThreadpoolWorkCallbacks(pw,TRUE);
     CloseThreadpoolWork(pw);
     ...
}

2　　每隔一段时间调用一次线程函数
　　先给出时间间隔线程函数模板



VOID CALLBACK TimerCallback(
   [in, out]            PTP_CALLBACK_INSTANCE Instance,
   [in, out, optional]  PVOID Context,
   [in, out]            PTP_TIMER Timer
);
　　CreateThreadpoolTimer创建时间间隔计时器对象



PTP_TIMER WINAPI CreateThreadpoolTimer(
   __in          PTP_TIMER_CALLBACK pfnti,
   __in_out_opt  PVOID pv,
   __in_opt      PTP_CALLBACK_ENVIRON pcbe
);
　　这个函数的参数和创建工作项的参数差不多。创建完毕后，调用SetThreadpoolTimer注册计时器。



VOID WINAPI SetThreadpoolTimer(
   __in_out      PTP_TIMER pti,
   __in_opt      PFILETIME pftDueTime,
   __in          DWORD msPeriod,
   __in_opt      DWORD msWindowLength
);
　　第一个参数是CreateThreadpoolTimer的返回值，第二个参数是第一次调用的开始时间，如果传值为NULL，表示停止调用。-1，立即开始。其他负值，表示调用SetThreadpoolTimer的相对时间。正值，表示，以1600年1月1日开始的绝对时间。第三个参数是调用时间间隔，0表示只调用一次。第4个参数用来个调用时间间隔增加随机性，比如第3个参数传递5，第4个参数传递2，表示在5-7毫秒内随机时间内调用回调函数。这样可以避免多个线程在同一时间调用上的冲突。
　　查看计时器是否被设置IsThreadpoolTimerSet



BOOL WINAPI IsThreadpoolTimerSet(
   __in_out      PTP_TIMER pti
);
　　等待计时器完成WaitForThreadpoolTimerCallbacks



VOID WINAPI WaitForThreadpoolTimerCallbacks(
   __in_out      PTP_TIMER pti,
   __in          BOOL fCancelPendingCallbacks
);
　　关闭计时器CloseThreadpoolTimer



VOID WINAPI CloseThreadpoolTimer(
   __in_out      PTP_TIMER pti
);
　　一个小例子：



VOID CALLBACK WorkThread2(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PTP_TIMER Timer)
{
     AfxMessageBox(_T("this is a TimerCallback fun"));
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
     ...
     PTP_TIMER pt = CreateThreadpoolTimer(WorkThread2,NULL,NULL);
     ULARGE_INTEGER ulRelativeStartTime;
     ulRelativeStartTime.QuadPart = (LONGLONG) -(10000000);  // start in 1 second
     FILETIME ftRelativeStartTime;
     ftRelativeStartTime.dwHighDateTime = ulRelativeStartTime.HighPart;
     ftRelativeStartTime.dwLowDateTime  = ulRelativeStartTime.LowPart;
     SetThreadpoolTimer(pt,&ftRelativeStartTime,2000,0);
     if (IsThreadpoolTimerSet(pt))
     {
         AfxMessageBox(_T("IsThreadpoolTimerSet TRUE"));
     }
     Sleep(5000);
     WaitForThreadpoolTimerCallbacks(pt,TRUE);
     CloseThreadpoolTimer(pt);
         ...
}
3　　　内核对象触发时调用一个函数
　　内核对象触发线程函数模板



VOID CALLBACK WaitCallback(
   [in, out]            PTP_CALLBACK_INSTANCE Instance,
   [in, out, optional]  PVOID Context,
   [in, out]            PTP_WAIT Wait,
   [in]                 TP_WAIT_RESULT WaitResult
);
　　CreateThreadpoolWait创建线程池等待对象



PTP_WAIT WINAPI CreateThreadpoolWait(
   __in          PTP_WAIT_CALLBACK pfnwa,
   __in_out_opt  PVOID pv,
   __in_opt      PTP_CALLBACK_ENVIRON pcbe
);
　　将内核对象绑定到线程池



VOID WINAPI SetThreadpoolWait(
   __in_out      PTP_WAIT pwa,
   __in_opt      HANDLE h,
   __in_opt      PFILETIME pftTimeout
);
　　第一个参数是CreateThreadpoolWait的返回值，第二个参数是内核对象句柄，第三个参数是表示线程池要花多长时间等待内核对象被触发，0表示不等待，NULL表示无限等待，负值表示相对时间，正值表示绝对时间。
　　WaitCallback最后一个参数表示回调函数被调用的原因。如果WaitResult是WAIT_OBJECT_0，表示SetThreadpoolWait的内核对象在超时之前被触发；WAIT_TIMEOUT表示超时；WAIT_ABANDONED_0表示内核对象是一个互斥信号量，且别抛弃。
　　等待完成



VOID WINAPI WaitForThreadpoolWaitCallbacks(
   __in_out      PTP_WAIT pwa,
   __in          BOOL fCancelPendingCallbacks
);
　　关闭



VOID WINAPI CloseThreadpoolWait(
   __in_out      PTP_WAIT pwa
);
　　小例子：



VOID CALLBACK WorkThread3(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PTP_WAIT Wait,TP_WAIT_RESULT WaitResult)
{
     AfxMessageBox(_T("this is a WaitCallback fun"));
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
     ...
　　PTP_WAIT pw = CreateThreadpoolWait(WorkThread3,NULL,NULL);
     HANDLE h = CreateEvent(NULL,TRUE,FALSE,NULL);
     //关联内核对象
     SetThreadpoolWait(pw,h,NULL);
     //0表示不等待，NULL表示无限等待，负值表示相对时间，正值表示绝对时间
     Sleep(1000);
     //触发内核对象
     SetEvent(h);
     Sleep(1000);
     WaitForThreadpoolWaitCallbacks(pw,TRUE);
     CloseThreadpoolWait(pw);
     CloseHandle(h);
     ...
}

4　　异步IO完成时调用函数
　　回调函数模板原型：



VOID CALLBACK IoCompletionCallback(
   [in, out]            PTP_CALLBACK_INSTANCE Instance,
   [in, out, optional]  PVOID Context,
   [in, out, optional]  PVOID Overlapped,
   [in]                 ULONG IoResult,
   [in]                 ULONG_PTR NumberOfBytesTransferred,
   [in, out]            PTP_IO Io
);
　　创建线程池IO对象



PTP_IO WINAPI CreateThreadpoolIo(
   __in          HANDLE fl,
   __in          PTP_WIN32_IO_CALLBACK pfnio,
   __in_out_opt  PVOID pv,
   __in_opt      PTP_CALLBACK_ENVIRON pcbe
);
　　第一个参数是具有OVERLAPPED标识的设备（文件、socket）句柄。其他三项不多说。
　　将线程池IO对象与线程池内部的完成端口关联：



VOID WINAPI StartThreadpoolIo(
   __in_out      PTP_IO pio
);
　　取消或解除与线程池关联：　　



VOID WINAPI CancelThreadpoolIo(
   __in_out      PTP_IO pio
);

VOID WINAPI CloseThreadpoolIo(
   __in_out      PTP_IO pio
);
　　等待线程池内核对象返回



VOID WINAPI WaitForThreadpoolIoCallbacks(
   __in_out      PTP_IO pio,
   __in          BOOL fCancelPendingCallbacks
);
　　例子：



VOID CALLBACK WorkThread4(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PVOID Overlapped,ULONG IoResult,ULONG_PTR NumberOfBytesTransferred,PTP_IO Io)
{
     AfxMessageBox(_T("this is a IoCompletionCallback fun"));
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
     ...
　　//打开D盘下文件a.txt
     HANDLE h = CreateFile(_T("D:\\a.txt"), GENERIC_READ,FILE_SHARE_READ, NULL, OPEN_EXISTING,
         FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
     //创建线程池IO对象
     PTP_IO pi = CreateThreadpoolIo(h,WorkThread4,NULL,NULL);
     //将线程池IO对象与线程池内部IOCP关联
     StartThreadpoolIo(pi);
     OVERLAPPED ol;
     ZeroMemory(&ol,sizeof(OVERLAPPED));
     char c[1024];
     DWORD readbytes = 0;
     //异步读取ReadFile
     if (!ReadFile(h,c,1024,&readbytes,&ol))
     {
         if (ERROR_IO_PENDING != GetLastError())
         {
             //如果不是ERROR_IO_PENDING，表明ReadFile出错，关闭IOCP关联
             CancelThreadpoolIo(pi);
         }
     }
     Sleep(2000);
     WaitForThreadpoolIoCallbacks(pi,TRUE);
     CloseThreadpoolIo(pi);
     ...
}
5　　回调函数的终止操作
　　回调函数内部可以使用以下几个API，当回调函数返回后，线程池将释放锁。

　　此外，还有CallbackMayRunLong函数，通知线程池当前任务运行时间比较长。如果CallbackMayRunLong函数返回TRUE，表示线程池中还有其他线程可用。返回FALSE，表示线程池中无其他任务可用。

6　　对线程池进行配置
　　这里说的线程池配置是对函数TrySubmitThreadpoolCallback用到的线程池（其他几种WORK\WAIT\TIMER\IO都用到内核对象，内核对象是不开源的），其他几种用到的都是系统默认的线程池，生命周期和进程一致。
　　创建一个线程池 CreateThreadpool



PTP_POOL WINAPI CreateThreadpool(
   PVOID reserved
);
　　设置私有线程池的上下线程数量



BOOL WINAPI SetThreadpoolThreadMinimum(
   __in_out      PTP_POOL ptpp,
   __in          DWORD cthrdMic
);

VOID WINAPI SetThreadpoolThreadMaximum(
   __in_out      PTP_POOL ptpp,
   __in          DWORD cthrdMost
);
　　关闭线程池



VOID WINAPI CloseThreadpool(
   __in_out      PTP_POOL ptpp
);