VC實現執行緒池

      這兩天在做關於網路蜘蛛的程式,希望可以通過執行緒池來提高程式的效能,網上搜索了一下,看到這方面的東西還不少,跟大家分享一下!~有許多應用程式建立的執行緒花費了大量時間在睡眠狀態來等待事件的發生。還有一些執行緒進入睡眠狀態後定期被喚醒以輪詢工作方式來改變或者更新狀態資訊。執行緒池可以讓你更有效地使用執行緒，它為你的應用程式提供一個由系統管理的工作者執行緒池。至少會有一個執行緒來監聽放到執行緒池的所有等待操作，當等待操作完成後，執行緒池中將會有一個工作者執行緒來執行相應的回撥函式。
你也可以把沒有等待操作的工作專案放到執行緒池中，用QueueUserWorkItem函式來完成這個工作，把要執行的工作專案函式通過一個引數傳遞給執行緒池。工作專案被放到執行緒池中後，就不能再取消了。
Timer-queue timers和Registered wait operations也使用執行緒池來實現。他們的回撥函式也放線上程池中。你也可以用BindIOCompletionCallback函式來投遞一個非同步IO操作，在IO完成埠上，回撥函式也是由執行緒池執行緒來執行。
當第一次呼叫QueueUserWorkItem函式或者BindIOCompletionCallback函式的時候，執行緒池被自動建立，或者Timer-queue timers或者Registered wait operations放入回撥函式的時候，執行緒池也可以被建立。執行緒池可以建立的執行緒數量不限，僅受限於可用的記憶體，每一個執行緒使用預設的初始堆疊大小，執行在預設的優先順序上。
執行緒池中有兩種型別的執行緒：IO執行緒和非IO執行緒。IO執行緒等待在可告警狀態，工作專案作為APC放到IO執行緒中。如果你的工作專案需要執行緒執行在可警告狀態，你應該將它放到IO執行緒。
非IO工作者執行緒等待在IO完成埠上，使用非IO執行緒比IO執行緒效率更高，也就是說，只要有可能的話，儘量使用非IO執行緒。IO執行緒和非IO執行緒在非同步IO操作沒有完成之前都不會退出。然而，不要在非IO執行緒中發出需要很長時間才能完成的非同步IO請求。
正確使用執行緒池的方法是，工作專案函式以及它將會呼叫到的所有函式都必須是執行緒池安全的。安全的函式不應該假設執行緒是一次性執行緒的或者是永久執行緒。一般來說，應該避免使用執行緒本地儲存和發出需要永久執行緒的非同步IO呼叫，比如說RegNotifyChangeKeyValue函式。如果需要在永久執行緒中執行這樣的函式的話，可以給QueueUserWorkItem傳遞一個選項WT_EXECUTEINPERSISTENTTHREAD。
注意，執行緒池不能相容COM的單執行緒套間（STA）模型。

    為了更深入地講解作業系統實現的執行緒池的優越性，我們首先嚐試著自己實現一個簡單的執行緒池模型。

    程式碼如下：

/************************************************************************/

/* Test Our own thread pool. */

/************************************************************************/

typedef struct _THREAD_POOL

{

HANDLE QuitEvent;

HANDLE WorkItemSemaphore;

LONG WorkItemCount;

LIST_ENTRY WorkItemHeader;

CRITICAL_SECTION WorkItemLock;

LONG ThreadNum;

HANDLE *ThreadsArray;

}THREAD_POOL, *PTHREAD_POOL;

typedef VOID (*WORK_ITEM_PROC)(PVOID Param);

typedef struct _WORK_ITEM

{

LIST_ENTRY List;

WORK_ITEM_PROC UserProc;

PVOID UserParam;

}WORK_ITEM, *PWORK_ITEM;

DWORD WINAPI WorkerThread(PVOID pParam)

{

PTHREAD_POOL pThreadPool = (PTHREAD_POOL)pParam;

HANDLE Events[2];

Events[0] = pThreadPool->QuitEvent;

Events[1] = pThreadPool->WorkItemSemaphore;

for(;;)

{

DWORD dwRet = WaitForMultipleObjects(2, Events, FALSE, INFINITE);

if(dwRet == WAIT_OBJECT_0)

break;

// execute user's proc.

elseif(dwRet == WAIT_OBJECT_0 +1)

{

PWORK_ITEM pWorkItem;

PLIST_ENTRY pList;

EnterCriticalSection(&pThreadPool->WorkItemLock);

_ASSERT(!IsListEmpty(&pThreadPool->WorkItemHeader));

pList = RemoveHeadList(&pThreadPool->WorkItemHeader);

LeaveCriticalSection(&pThreadPool->WorkItemLock);

pWorkItem = CONTAINING_RECORD(pList, WORK_ITEM, List);

pWorkItem->UserProc(pWorkItem->UserParam);

InterlockedDecrement(&pThreadPool->WorkItemCount);

free(pWorkItem);

}

else

{

_ASSERT(0);

break;

}

return0;

}

BOOL InitializeThreadPool(PTHREAD_POOL pThreadPool, LONG ThreadNum)

{

pThreadPool->QuitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

pThreadPool->WorkItemSemaphore = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL);

pThreadPool->WorkItemCount =0;

InitializeListHead(&pThreadPool->WorkItemHeader);

InitializeCriticalSection(&pThreadPool->WorkItemLock);

pThreadPool->ThreadNum = ThreadNum;

pThreadPool->ThreadsArray = (HANDLE*)malloc(sizeof(HANDLE) * ThreadNum);

for(int i=0; i<ThreadNum; i++)

{

pThreadPool->ThreadsArray[i] = CreateThread(NULL, 0, WorkerThread, pThreadPool, 0, NULL);

}

return TRUE;

}

VOID DestroyThreadPool(PTHREAD_POOL pThreadPool)

{

SetEvent(pThreadPool->QuitEvent);

for(int i=0; i<pThreadPool->ThreadNum; i++)

{

WaitForSingleObject(pThreadPool->ThreadsArray[i], INFINITE);

CloseHandle(pThreadPool->ThreadsArray[i]);

}

free(pThreadPool->ThreadsArray);

CloseHandle(pThreadPool->QuitEvent);

CloseHandle(pThreadPool->WorkItemSemaphore);

DeleteCriticalSection(&pThreadPool->WorkItemLock);

while(!IsListEmpty(&pThreadPool->WorkItemHeader))

{

PWORK_ITEM pWorkItem;

PLIST_ENTRY pList;

pList = RemoveHeadList(&pThreadPool->WorkItemHeader);

pWorkItem = CONTAINING_RECORD(pList, WORK_ITEM, List);

free(pWorkItem);

}

BOOL PostWorkItem(PTHREAD_POOL pThreadPool, WORK_ITEM_PROC UserProc, PVOID UserParam)

{

PWORK_ITEM pWorkItem = (PWORK_ITEM)malloc(sizeof(WORK_ITEM));

if(pWorkItem == NULL)

return FALSE;

pWorkItem->UserProc = UserProc;

pWorkItem->UserParam = UserParam;

EnterCriticalSection(&pThreadPool->WorkItemLock);

InsertTailList(&pThreadPool->WorkItemHeader, &pWorkItem->List);

LeaveCriticalSection(&pThreadPool->WorkItemLock);

InterlockedIncrement(&pThreadPool->WorkItemCount);

ReleaseSemaphore(pThreadPool->WorkItemSemaphore, 1, NULL);

return TRUE;

}

VOID UserProc1(PVOID dwParam)

{

WorkItem(dwParam);

}

void TestSimpleThreadPool(BOOL bWaitMode, LONG ThreadNum)

{

THREAD_POOL ThreadPool;

InitializeThreadPool(&ThreadPool, ThreadNum);

CompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

BeginTime = GetTickCount();

ItemCount =20;

for(int i=0; i<20; i++)

{

PostWorkItem(&ThreadPool, UserProc1, (PVOID)bWaitMode);

}

WaitForSingleObject(CompleteEvent, INFINITE);

CloseHandle(CompleteEvent);

DestroyThreadPool(&ThreadPool);

}

我們把工作專案放到一個佇列中，用一個訊號量通知執行緒池，執行緒池中任意一個執行緒取出工作專案來執行，執行完畢之後，執行緒返回執行緒池，繼續等待新的工作專案。

執行緒池中執行緒的數量是固定的，預先建立好的，永久的執行緒，直到銷燬執行緒池的時候，這些執行緒才會被銷燬。

執行緒池中執行緒獲得工作專案的機會是均等的，隨機的，並沒有特別的方式保證哪一個執行緒具有特殊的優先獲得工作專案的機會。

而且，同一時刻可以併發執行的執行緒數目沒有任何限定。事實上，在我們的執行計算任務的演示程式碼中，所有的執行緒都併發執行。

下面，我們再來看一下，完成同樣的任務，系統提供的執行緒池是如何運作的。

/************************************************************************/

VC實現執行緒池

基於C++11實現執行緒池的工作原理.

基於C++11實現執行緒池的工作原理

基於C++11 thread 實現執行緒池

使用C++11實現執行緒池的兩種方法

使用c語言實現執行緒池以及執行緒池原理

Spring+TaskExecutor實現執行緒池管理

c++11實現執行緒池

執行緒池原理及C語言實現執行緒池

【Linux】生產者消費者程式設計實現-執行緒池+訊號量

如何實現執行緒池的暫停和恢復功能

spring 無配置檔案實現執行緒池管理

[C++]C++ 100行實現執行緒池

【原始碼剖析】threadpool —— 基於 pthread 實現的簡單執行緒池

【Java】執行緒池ThreadPoolExecutor實現原理

實現一個執行緒池

【程式設計筆記】執行緒池實現原始碼（從POCO中剝離出來）

如何實現自己的執行緒池（不看後悔，一看必懂）

執行緒池與cp命令的實現

Java中的執行緒池及其實現類ThreadPoolExecutor

VC實現執行緒池

相關推薦