欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

线程池 -> 【Windows核心编程(第五版)】

程序员文章站 2022-06-11 21:42:05
...

 

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表示调用失败。

一个小例子为:

#include <iostream>
#include <windows.h>
#include <winbase.h>
#include <strsafe.h>
using namespace std;
 
 
extern "C" BOOL WINAPI TrySubmitThreadpoolCallback(
   PTP_SIMPLE_CALLBACK  pfns,
     PVOID                pv,
    PTP_CALLBACK_ENVIRON pcbe
    );
 
 
void CALLBACK MyProc(PTP_CALLBACK_INSTANCE instance,PVOID pContext)
{
    SYSTEMTIME tm;
    GetLocalTime(&tm);
    char strText[MAX_PATH];
    StringCchPrintfA(strText,MAX_PATH,"MyProc is runing within thread ID is %d ,current time %d:%d"   \
                     ,GetCurrentThreadId(),tm.wHour,tm.wMinute);
    cout<<strText<<endl;
 
}
 
int main(int argc, char *argv[])
{
 
    cout<<"Call the TrySubmitThreadpoolCallback function to execute myproc,"   \
                  "thread ID of caller is "<<GetCurrentThreadId()<<endl;
    TrySubmitThreadpoolCallback(MyProc,NULL,NULL);
 
    SleepEx(INFINITE,FALSE);
    return 0;
}

 

利用TrySubmitThreadpoolCallback函数有可能失败,这时线程将不会启动。

为了确保线程能够启动过,必须显示创建一个工作项对象,直到把工作项提交到线程池中。

创建工作项函数如下:

PTP_WORK WINAPI CreateThreadpoolWork(
  __in         PTP_WORK_CALLBACK pfnwk,
  __inout_opt  PVOID pv,
  __in_opt     PTP_CALLBACK_ENVIRON pcbe
);

第一个参数是线程函数;

第二个参数是给线程函数传的值(Context);

第三个参数用作对线程池定制。这个函数使用的线程函数模板是:

VOID CALLBACK WorkCallback(
  __inout      PTP_CALLBACK_INSTANCE Instance,
  __inout_opt  PVOID Context,
  __inout      PTP_WORK Work
);

 

创建工作项后,需要提交工作项给线程池,让线程池分配线程处理该项。

提交工作项请求的函数是SubmitThreadpoolWork,定义如下:

VOID WINAPI SubmitThreadpoolWork(
  __inout  PTP_WORK pwk
);


等待工作项完成的函数是WaitForThreadpoolWorkCallbacks,定义如下:

VOID WINAPI WaitForThreadpoolWorkCallbacks(
  __inout  PTP_WORK pwk,
  __in     BOOL fCancelPendingCallbacks
);

该函数的第二个参数,如果传值为TRUE,试图取消提交的工作项。

如果工作项已启动,则等待;FALSE,当前线程挂起,直到工作项完成。

 

取消工作项的函数是CloseThreadpoolWork,定义如下:

VOID WINAPI CloseThreadpoolWork(
  __inout  PTP_WORK pwk
);

 

 一个简单的例子为:

 1 VOID CALLBACK WorkThread1(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PTP_WORK Work)
 2 {
 3     for (int i=0;i<5;i++)
 4     {
 5         AfxMessageBox(_T("this is a WorkCallback fun"));
 6         Sleep(1000);
 7     }
 8 }
 9 
10 int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
11 {
12     ...
13     PTP_WORK pw = CreateThreadpoolWork(WorkThread1,NULL,NULL);
14     SubmitThreadpoolWork(pw);
15     //给线程足够多的时间启动
16     Sleep(2000);
17     //TRUE,试图取消提交的工作项。如果工作项已启动,则等待;
18     //FALSE,当前线程挂起,直到工作项完成
19     WaitForThreadpoolWorkCallbacks(pw,TRUE);
20     CloseThreadpoolWork(pw);
21     ...
22 }

2. 每隔一段时间调用一次线程函数

  先给出时间间隔线程函数模板

1 VOID CALLBACK TimerCallback(
2   [in, out]            PTP_CALLBACK_INSTANCE Instance,
3   [in, out, optional]  PVOID Context,
4   [in, out]            PTP_TIMER Timer
5 );

  CreateThreadpoolTimer创建时间间隔计时器对象

1 PTP_TIMER WINAPI CreateThreadpoolTimer(
2   __in          PTP_TIMER_CALLBACK pfnti,
3   __in_out_opt  PVOID pv,
4   __in_opt      PTP_CALLBACK_ENVIRON pcbe
5 );

  这个函数的参数和创建工作项的参数差不多。创建完毕后,调用SetThreadpoolTimer注册计时器。

1 VOID WINAPI SetThreadpoolTimer(
2   __in_out      PTP_TIMER pti,
3   __in_opt      PFILETIME pftDueTime,
4   __in          DWORD msPeriod,
5   __in_opt      DWORD msWindowLength
6 );

  第一个参数是CreateThreadpoolTimer的返回值,第二个参数是第一次调用的开始时间,如果传值为NULL,表示停止调用。-1,立即开始。其他负值,表示调用SetThreadpoolTimer的相对时间。正值,表示,以1600年1月1日开始的绝对时间。第三个参数是调用时间间隔,0表示只调用一次。第4个参数用来个调用时间间隔增加随机性,比如第3个参数传递5,第4个参数传递2,表示在5-7毫秒内随机时间内调用回调函数。这样可以避免多个线程在同一时间调用上的冲突。

  查看计时器是否被设置IsThreadpoolTimerSet

1 BOOL WINAPI IsThreadpoolTimerSet(
2   __in_out      PTP_TIMER pti
3 );

  等待计时器完成WaitForThreadpoolTimerCallbacks

1 VOID WINAPI WaitForThreadpoolTimerCallbacks(
2   __in_out      PTP_TIMER pti,
3   __in          BOOL fCancelPendingCallbacks
4 );

  关闭计时器CloseThreadpoolTimer

1 VOID WINAPI CloseThreadpoolTimer(
2   __in_out      PTP_TIMER pti
3 );

 一个小例子:

#define _WIN32_WINNT 0x0600
#include <iostream>
#include <windows.h>
#include <winbase.h>
#include <strsafe.h>
#include <threadpoolapiset.h>
using namespace std;
 
 
 
 
void CALLBACK MyProc(PTP_CALLBACK_INSTANCE instance,PVOID pContext,PTP_WORK Work)
{
    SYSTEMTIME tm;
    GetLocalTime(&tm);
    char strText[MAX_PATH];
    StringCchPrintfA(strText,MAX_PATH,"MyProc is runing within thread ID is %d ,current time %d:%d"   \
                     ,GetCurrentThreadId(),tm.wHour,tm.wMinute);
    cout<<strText<<endl;
 
}
 
 
 
int main(int argc, char *argv[])
{
 
    PTP_WORK pWork =  CreateThreadpoolWork(MyProc,NULL,NULL);
    cout<<"thread ID of caller is "<<GetCurrentThreadId()<<endl;
    for(int i= 0; i !=5 ;++i)
    {
            SubmitThreadpoolWork(pWork);
    }
 
    WaitForThreadpoolWorkCallbacks(pWork,FALSE);
    CloseThreadpoolWork(pWork);
 
    return 0;
}

线程池 -> 【Windows核心编程(第五版)】
 

 

 3. 内核对象触发时调用一个函数

 内核对象触发线程函数模板

VOID CALLBACK WaitCallback(
  __inout      PTP_CALLBACK_INSTANCE Instance,
  __inout_opt  PVOID Context,
  __inout      PTP_WAIT Wait,
  __in         TP_WAIT_RESULT WaitResult
);

 CreateThreadpoolWait创建线程池等待对象

PTP_WAIT WINAPI CreateThreadpoolWait(
  __in         PTP_WAIT_CALLBACK pfnwa,
  __inout_opt  PVOID pv,
  __in_opt     PTP_CALLBACK_ENVIRON pcbe
);


 将内核对象绑定到线程池

VOID WINAPI SetThreadpoolWait(
  __inout   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
);

  小例子:

 1 VOID CALLBACK WorkThread3(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PTP_WAIT Wait,TP_WAIT_RESULT WaitResult)
 2 {
 3     AfxMessageBox(_T("this is a WaitCallback fun"));
 4 }
 5 
 6 int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
 7 {
 8     ...
 9   PTP_WAIT pw = CreateThreadpoolWait(WorkThread3,NULL,NULL);
10     HANDLE h = CreateEvent(NULL,TRUE,FALSE,NULL);
11     //关联内核对象
12     SetThreadpoolWait(pw,h,NULL);
13     //0表示不等待,NULL表示无限等待,负值表示相对时间,正值表示绝对时间
14     Sleep(1000);
15     //触发内核对象
16     SetEvent(h);
17     Sleep(1000);
18     WaitForThreadpoolWaitCallbacks(pw,TRUE);
19     CloseThreadpoolWait(pw);
20     CloseHandle(h);
21     ...
22 }

 

4. 异步IO完成时调用函数

  回调函数模板原型:

1 VOID CALLBACK IoCompletionCallback(
2   [in, out]            PTP_CALLBACK_INSTANCE Instance,
3   [in, out, optional]  PVOID Context,
4   [in, out, optional]  PVOID Overlapped,
5   [in]                 ULONG IoResult,
6   [in]                 ULONG_PTR NumberOfBytesTransferred,
7   [in, out]            PTP_IO Io
8 );
创建线程池IO对象
1 PTP_IO WINAPI CreateThreadpoolIo(
2   __in          HANDLE fl,
3   __in          PTP_WIN32_IO_CALLBACK pfnio,
4   __in_out_opt  PVOID pv,
5   __in_opt      PTP_CALLBACK_ENVIRON pcbe
6 );

  第一个参数是具有OVERLAPPED标识的设备(文件、socket)句柄。其他三项不多说。

  将线程池IO对象与线程池内部的完成端口关联:

1 VOID WINAPI StartThreadpoolIo(
2   __in_out      PTP_IO pio
3 );

  取消或解除与线程池关联:  

1 VOID WINAPI CancelThreadpoolIo(
2   __in_out      PTP_IO pio
3 );
4 
5 
6 VOID WINAPI CloseThreadpoolIo(
7   __in_out      PTP_IO pio
8 );

 

  等待线程池内核对象返回

1 VOID WINAPI WaitForThreadpoolIoCallbacks(
2   __in_out      PTP_IO pio,
3   __in          BOOL fCancelPendingCallbacks
4 );

  例子:

#define _WIN32_WINNT 0x0600
#include <iostream>
#include <windows.h>
#include <winbase.h>
#include <strsafe.h>
#include <threadpoolapiset.h>
using namespace std;
 
typedef struct MYOVERLAPPED
{
    OVERLAPPED overlapped;
    enum{read,write}modle;
    LPVOID pBuffer;
    DWORD dwNumByte;
};
 
 
VOID CALLBACK MyIoCompletionFunc(PTP_CALLBACK_INSTANCE instance,PVOID pContext,PVOID pOverlapped,    \
                                 ULONG IoResult,ULONG NumOfTransferred,PTP_IO Io)
{
    char * strBuffer = (char*) (((MYOVERLAPPED*)pOverlapped)->pBuffer);
    if(IoResult == NO_ERROR)
    {
        cout<<"Reading file completion!!"<<endl<<endl;
        cout<<strBuffer<<endl;
    }
}
 
int main(int argc,char *argv[])
{
    char * str_filename = "C:\\Users\\Administrator\\Desktop\\1.txt";
    HANDLE hFile = CreateFileA(str_filename,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,    \
                               FILE_FLAG_OVERLAPPED|FILE_FLAG_NO_BUFFERING,NULL);
    if(!hFile && GetLastError() == ERROR_FILE_NOT_FOUND)
    {
        cout<<"Failed to found the file \""<<str_filename<<"\" !"<<endl;
    }
    PTP_IO pIo = CreateThreadpoolIo(hFile,MyIoCompletionFunc,NULL,NULL);
    if(pIo)
    {
        StartThreadpoolIo(pIo);
    }
    MYOVERLAPPED overlap;
    ZeroMemory(&overlap,sizeof(MYOVERLAPPED));
    LARGE_INTEGER fileSize;
    GetFileSizeEx(hFile,&fileSize);
    DWORD dwSize = (64-fileSize.QuadPart%64)+fileSize.QuadPart;
    char *strBuffer =  (char *)VirtualAlloc(NULL,dwSize,MEM_COMMIT,PAGE_READWRITE);//new char[fileSize.LowPart];
    overlap.modle = MYOVERLAPPED::read;
    overlap.pBuffer = strBuffer;
    overlap.dwNumByte = fileSize.QuadPart;
 
    DWORD dwReaded;
    if(!ReadFile(hFile,strBuffer,dwSize,&dwReaded,(LPOVERLAPPED)&overlap))
    {
        if(ERROR_IO_PENDING == GetLastError())
        {
            cout<<"Post IRP of reading to the file device"<<endl;
        }
        else
        {
            cout<<"Read file failed!"<<endl;
        }
    }
    Sleep(2000);
    WaitForThreadpoolIoCallbacks(pIo,FALSE);
    SleepEx(INFINITE,FALSE);
 
 
    return 0;
}

 

 5. 回调函数的终止操作

  回调函数内部可以使用以下几个API,当回调函数返回后,线程池将释放锁。 

线程池 -> 【Windows核心编程(第五版)】

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

6. 对线程池进行配置

   这里说的线程池配置是对函数TrySubmitThreadpoolCallback用到的线程池(其他几种WORK\WAIT\TIMER\IO都用到内核对象,内核对象是不开源的),其他几种用到的都是系统默认的线程池,生命周期和进程一致。

  创建一个线程池 CreateThreadpool

1 PTP_POOL WINAPI CreateThreadpool(
2   PVOID reserved
3 );

   设置私有线程池的上下线程数量

1 BOOL WINAPI SetThreadpoolThreadMinimum(
2   __in_out      PTP_POOL ptpp,
3   __in          DWORD cthrdMic
4 );
5 
6 VOID WINAPI SetThreadpoolThreadMaximum(
7   __in_out      PTP_POOL ptpp,
8   __in          DWORD cthrdMost
9 );

  关闭线程池

1 VOID WINAPI CloseThreadpool(
2   __in_out      PTP_POOL ptpp
3 );