线程池(译)

这是我翻译的codeproject上面的一篇文章，题目是：线程池

一 简介

 　　我的应用中，需要将数据备份到不同的地方(CD,USB,网络共享)。如果我只用单线程来做这件事情，需要花2个小时以上。而如何改善性能对我来说是一个挑战，最终我用多线程来实现了这个问题，结果非常可观，只用了30分钟就完成了我的工作。

　　其实在刚开始开发时，备份耗费了一整天，后来我被迫增加频率到1个小时。现在我发现了一个问题：实际中由于频率过低导致线程频繁的重复创建和销毁。怎么解决这个问题？为什么线程不能被重复利用呢？所以这就是线程池的由来。

• 你是否需要线程池？
• 你有多个请求需要被重复和并行处理吗？
• 每个请求能独立工作吗？
• 你需要等待IO/File操作吗？

如果你的回答是肯定的，那么线程池非常适合你。你的程序会因此具有低耦合性并且易于实现。

二 背景

　　作为一名码农，你应该至少有过一次使用单线程的经历，我也无例外。现在我需要创建一个线程池并用C++实现，于是我Google并下载了很多例子，但是它们都不凑效，虽然例子很多，但是没有适合我需要的，所以我写下了这边文章。

　　我为什么需要一个线程次？一般大多数的IO操作(比如文件，磁盘等)比较耗时，所以用单线程的话，很多系统资源(比如内存，处理器等)会处于等待状态，这显然是一种浪费。这时用多线程的话就能有效利用空闲时间，提高内存和处理器利用率。

　　对于这些情况下的一些应用使用线程池会比较有效:

• 它要求避免线程创建和销毁等操作带来的时间消耗
• 它是并行的，而且会异步分发大量的小任务
• 它会创建和销毁大量的线程(这些线程运行时间比较短)。用线程池的话会减少线程管理的复杂度，以及线程创建销毁负荷
• 它会在后台并行处理一些独立的任务

　　线程次的创建

　　　　线程池会创建指定数量的线程并等待调用请求。一旦收到一个线程使用请求，它会激活一个线程并开始执行。等执行完成以后，这个线程会变成等待状态，然后等待下一次的请求。如果要求请求清除，所有的线程将会退出线程池。

关系图如下所示：

下面是其中的类的介绍：

• ThreadPool

　　这个类用于创建，管理和销毁线程池。在使用时，你可以创建一个ThreadPool的对象，并可以指定需要创建的线程数量。这里的线程池最大支持64个线程，它也可以减少至最小线程数以避免过度线程切换和系统资源消耗。

• AbstractRequest

　　这个类代表了对线程池的请求操作。客户端应用应该继承这个类，并重载其Execute()函数。并且你需要利用其提供的临界区对象来保证线程安全。取消操作可以通过IsAborted()函数来判断。把继承的抽象请求发送到线程池让其处理，也可以通过Abort()取消。

• Logger

　　线程池有错误信息和log记录功能。默认的log输出是在调试窗口。你也可以创建一个继承Logger的自定义的类并重载这个输出，并实现其中的LogError()和LogInfo()函数。然后将Logger类实例在线程池创建的时候传递给它就可以了。

下面这张图说明了如何在你的应用中使用线程池？

 　　应用程序中有一个ThreadPool的实例，当接收到创建请求时，这个类会创建指定数量的线程，每个线程都将等待被调用。一旦接收到请求，其中的一个线程将结束等待状态并开始处理请求。等处理完成以后，线程恢复到等待状态。用户在任何时候都能调用AbstractRequest的Abort()来中止请求过程。线程池在处理完请求后不会删除它。

三 示例

• Create()

// Create thread pool with specified number of threads.

bool Create( const unsigned short usThreadCount_i, Logger* pLogger_io = NULL );

这个函数将创建指定数量的线程并进入等待状态。如果指定了Logger，它将会被用来处理错误。这个函数失败时返回false，最大数量的线程数是64

• Destroy()

// Destroy the existing thread pool.

bool Destroy();

这个函数中止所有的请求并销毁线程池。失败时返回false。

• PostRequest()

// Post request to thread pool for processing.

bool PostRequest( AbstractRequest* pRequest_io );

这个函数发送指定的请求到线程池，失败时返回false

依赖关系

　　ThreadPool.h 包含了windows.h, list.h (STL) 和 string.h (STL)

如何在你的应用中使用线程池？

1. 包含ThreadPool.h和ThreadPool.cpp
2. 如果有需要，线程池可以打印错误信息到调试窗口，而且这个行为可以通过重载来实现。默认的行为可以从Logger来继承一个类，并重载LogError()和LogInfo()函数。
3. 用Create()创建线程池，如果有需要的话可以提供Logger
4. 创建一个继承自AbtractRequest的类，可以实现Execute()函数作为线程函数
5. 创建继承自AbtractRequest的类实例，并传递给线程此用来处理PostRequest()函数。用户可以无限制的发送请求，但是被激活的请求数量等于线程数量
6. 一旦处理完成以后，能调用Destroy()销毁线程池。

ThreadPoolDemo 是一个应用ThreadPool类的demo。这个线程池针对Windows操作系统，也可以移植到Linux和IOS平台。可以在本文最下面提供的下载链接获取。

这里是ThreadPool的代码：

/**
 * @author :    Suresh
 */

#ifndef _THREAD_POOL_MGR_H_
#define _THREAD_POOL_MGR_H_

#include <windows.h>
#include <list>

namespace TP
{

    /**
     * Logger - This is base class for the error logger class and it is polymorphic.
     *          The users of the ThreadPool create a class which derived from this 
     *          and override LogError() and LogInfo() for their own error logging mechanism.
     *          The default error logging will be in output window.
     */
    class Logger
    {

    public:

        // Constructor
        Logger(){};
        // Destructor
        virtual ~Logger(){};
        // Log error description.
        void LogError( const long lActiveReq_i, const std::wstring& wstrError_i );
        // Log information.
        void LogInfo( const long lActiveReq_i, const std::wstring& wstrInfo_i );
        // Override this function to log errors. Default log will be in output window.
        virtual void LogError( const std::wstring& wstrError_i );
        // Override this function to log informations. Default log will be in output window.
        virtual void LogInfo( const std::wstring& wstrInfo_i );

    private:

        // Log thread ID, Active thread count and last error.
        void PrepareLog( const long lActiveReq_i, std::wstring& wstrLog_io );
    };

    /**
     * SyncObject - The class is a wrapper of Critical section object to provide
     *              synchronization for thread pool.
     */
    class SyncObject
    {

    public:
        // Constructor
        SyncObject()
        {
            ::InitializeCriticalSection( &m_stCriticalSection );
        }

        // Destructor
        ~SyncObject()
        {
            ::DeleteCriticalSection( &m_stCriticalSection );
        }

        // Lock critical section.
        bool Lock()
        {
            ::EnterCriticalSection( &m_stCriticalSection );
            return true;
        }

        // Unlock critical section.
        bool Unlock()
        {
            ::LeaveCriticalSection( &m_stCriticalSection );
            return true;
        }

    private:
        SyncObject( const SyncObject& );
        SyncObject& operator = ( const SyncObject& );

    private:

        // Critical section object.
        CRITICAL_SECTION m_stCriticalSection;
    };

    /**
     * AutoLock - This class own synchronization object during construction and
     *            release the ownership during the destruction.
     */
    class AutoLock
    {

    public:

        /** 
         * Parameterized constructor
         * 
         * @param       LockObj_i - Synchronization object.
         * @return      Nil
         * @exception   Nil
         * @see         Nil
         * @since       1.0
         */
        AutoLock( SyncObject& LockObj_i ) : m_pSyncObject( &LockObj_i )
        {
            if( NULL != m_pSyncObject )
            {
                m_pSyncObject->Lock();
            }
        }

        /** 
         * Destructor.
         * 
         * @param       Nil
         * @return      Nil
         * @exception   Nil
         * @see         Nil
         * @since       1.0
         */
        ~AutoLock()
        {
            if( NULL != m_pSyncObject )
            {
                m_pSyncObject->Unlock();
                m_pSyncObject = NULL;
            }
        }

    private:
        SyncObject* m_pSyncObject;
    };


    /**
     * AbstractRequest - This is abstract base class for the request to be processed in thread pool.
     *                   and it is polymorphic. The users of the ThreadPool must create a class 
     *                   which derived from this and override Execute() function.
     */
    class AbstractRequest
    {

    public:
        // Constructor
        AbstractRequest() : m_bAborted( false ), m_usRequestID( 0u ){}
        // Destructor
        virtual ~AbstractRequest(){}
        // Thread procedure to be override in derived class. This function should return if request aborted.
        // Abort request can check by calling IsAborted() function during time consuming operation.
        virtual long Execute() = 0;
        // Set request ID.
        void SetRequestID( unsigned short uRequestID_i )
        {
            AutoLock LockRequest( m_LockWorkerThread );
            m_usRequestID = uRequestID_i;
        }
        // Get request ID.
        unsigned short GetRequestID()
        {
            AutoLock LockRequest( m_LockWorkerThread );
            return m_usRequestID;
        }
        // Abort the processing of the request.
        void Abort()
        {
            AutoLock LockRequest( m_LockWorkerThread );
            m_bAborted = true;
        }
        // Clear abort flag for re-posting the same request.
        void ClearAbortFlag()
        {
            AutoLock LockRequest( m_LockWorkerThread );
            m_bAborted = false;
        }

    protected:
        // Check for the abort request
        bool IsAborted()
        {
            AutoLock LockRequest( m_LockWorkerThread );
            return m_bAborted;
        }
        // Prepare error or information log.
        void PrepareLog( std::wstring& wstrLog_io );

    protected:
        // Synchronization object for resource locking.
        SyncObject m_LockWorkerThread;

    private:
        // Abort flag.
        bool m_bAborted;
        // Request Identifier.
        unsigned short m_usRequestID;

    };

    /**
     * AutoCounter - Increment and decrement counter
     */
    class AutoCounter
    {

    public:
        // Constructor.
        AutoCounter( unsigned short& usCount_io,
                     SyncObject& Lock_io ) :
                     m_usCount( usCount_io ), m_LockThread( Lock_io )
        {
            AutoLock Lock( m_LockThread );
            m_usCount++;
        }

        // Destructor.
        ~AutoCounter()
        {
            AutoLock Lock( m_LockThread );
            m_usCount--;
        }

    private:
        // Counter variable.
        unsigned short& m_usCount;
        // Synchronization object for resource locking.
        SyncObject& m_LockThread;
    };


    typedef std::list<AbstractRequest*> REQUEST_QUEUE;


    /**
     * ThreadPool - This class create and destroy thread pool based on the request.
     *              The requested to be processed can be post to pool as derived object of 
     *              AbstractRequest. Also a class can be derive from Logger to error and
     *              information logging.
     */
    class ThreadPool
    {

    public:
        // Constructor.
        ThreadPool();
        // Destructor.
        ~ThreadPool();

        // Create thread pool with specified number of threads.
        bool Create( const unsigned short usThreadCount_i, Logger* pLogger_io = NULL );
        // Destroy the existing thread pool.
        bool Destroy();
        // Post request to thread pool for processing.
        bool PostRequest( AbstractRequest* pRequest_io );

    private:
        AbstractRequest* PopRequest( REQUEST_QUEUE& RequestQueue_io );
        bool AddThreads();
        bool NotifyThread();
        bool ProcessRequests();
        bool WaitForRequest();
        bool DestroyPool();
        bool IsDestroyed();
        void SetDestroyFlag( const bool bFlag_i );
        void CancelRequests();
        void LogError( const std::wstring& wstrError_i );
        void LogInfo( const std::wstring& wstrInfo_i );
        static UINT WINAPI ThreadProc( LPVOID pParam_i );

    private:
        ThreadPool( const ThreadPool& );
        ThreadPool& operator = ( const ThreadPool& );

    private:
        // Used for thread pool destruction.
        bool m_bDestroyed;
        // Hold thread count in the pool.
        unsigned short m_usThreadCount;
        // Released semaphore count.
        unsigned short m_usSemaphoreCount;
        // Active thread count.
        unsigned short m_lActiveThread;
        // Active thread count.
        unsigned short m_usPendingReqCount;
        // Manage active thread count in pool.
        HANDLE m_hSemaphore;
        // Hold thread handles.
        HANDLE* m_phThreadList;
        // Request queue.
        REQUEST_QUEUE m_RequestQueue;
        // Synchronization object for resource locking.
        SyncObject m_LockWorkerThread;
        // User defined error and information logger class.
        Logger* m_pLogger;
        // Default error and information logger.
        Logger m_Logger;
    };
} // namespace TP

#endif // #ifndef _THREAD_POOL_MGR_H_

/**
 * @author :    Suresh
 */

#include "ThreadPool.h"
#include <sstream>
#include <iomanip>

namespace TP
{

    /** 
     * Log error description.
     * 
     * @param       lActiveReq_i - Count of active requests.
     * @param       wstrError_i  - Error message.
     */
    void Logger::LogError( const long lActiveReq_i, const std::wstring& wstrError_i )
    {
        std::wstring wstrLog( wstrError_i );
        PrepareLog( lActiveReq_i, wstrLog );
        LogError( wstrLog );
    }


    /** 
     * Log information.
     * 
     * @param       lActiveReq_i - Count of active requests.
     * @param       wstrInfo_i   - Information message.
     */
    void Logger::LogInfo( const long lActiveReq_i, const std::wstring& wstrInfo_i )
    {
        std::wstring wstrLog( wstrInfo_i );
        PrepareLog( lActiveReq_i, wstrLog );
        LogInfo( wstrLog );
    }


    /** 
     * Override this function to log errors. Default log will be in output window.
     * 
     * @param       wstrError_i  - Error description
     */
    void Logger::LogError( const std::wstring& wstrError_i )
    {
        OutputDebugString( wstrError_i.c_str());
    }


    /** 
     * Override this function to log informations. Default log will be in output window.
     * 
     * @param       wstrInfo_i   - Information description.
     */
    void Logger::LogInfo( const std::wstring& wstrInfo_i )
    {
        OutputDebugString( wstrInfo_i.c_str());
    }


    /** 
     * Log thread ID, Active thread count and last error.
     * 
     * @param       lActiveReq_i - Active thread count.
     * @param       wstrLog_io   - Error or information description
     */
    void Logger::PrepareLog( const long lActiveReq_i, std::wstring& wstrLog_io )
    {
        std::wstringstream wstrmLog;
        wstrmLog << L"##TP## [TID=" << std::setfill( L'0' ) << std::setw(8) << ::GetCurrentThreadId()
                 << L"] [ACTIVE REQUEST=" << std::setw(4) << lActiveReq_i
                 << L"] [LAST ERROR=" << std::setw(4) << ::GetLastError()
                 << L"] " << wstrLog_io.c_str() << + L"]";
        wstrLog_io = wstrmLog.str();
    }


    /** 
     * Prepare error or information log.
     * 
     * @param       wstrLog_io - Log information
     */
    void AbstractRequest::PrepareLog( std::wstring& wstrLog_io )
    {
        std::wstringstream wstrmLog;
        wstrmLog << std::setfill( L'0' );
        wstrmLog << L"##RQ## [RID=" << std::setw(8) << GetRequestID()
                 << L"] [Desc=" << wstrLog_io.c_str() << + L"]";
        wstrLog_io = wstrmLog.str();
    }


    /** 
     * Constructor
     */
    ThreadPool::ThreadPool() : m_bDestroyed( false ),
                               m_usThreadCount( 0u ),
                               m_usSemaphoreCount( 0u ),
                               m_lActiveThread( 0u ),
                               m_usPendingReqCount( 0u ),
                               m_hSemaphore( NULL ),
                               m_phThreadList( NULL ),
                               m_pLogger( &m_Logger )
    {
    }


    /** 
     * Destructor
     */
    ThreadPool::~ThreadPool()
    {
        if( NULL != m_phThreadList )
        {
            if( !Destroy())
            {
                LogError( L"Destroy() failed" );
            }
        }
    }


    /** 
     * Create thread pool with specified number of threads.
     * 
     * @param       usThreadCount_i - Thread count.
     * @param       pLogger_i       - Logger instance to log errors and informations
     */
    bool ThreadPool::Create( const unsigned short usThreadCount_i, Logger* pLogger_i )
    {
        try
        {
            // Assign logger object. If user not provided then use existing and
            // error will be logged in output window.
            m_pLogger = ( NULL != pLogger_i ) ? pLogger_i : &m_Logger;
            // Check thread pool is initialized already.
            if( NULL != m_phThreadList )
            {
                LogError( L"ThreadPool already created" );
                return false;
            }
            // Validate thread count.
            if( 0 == usThreadCount_i )
            {
                LogError( L"Minimum allowed thread count is one" );
                return false;
            }
            if( usThreadCount_i > 64 )
            {
                LogError( L"Maximum allowed thread count is 64" );
                return false;
            }
            LogInfo( L"Thread pool creation requested" );

            // Initialize values.
            m_lActiveThread = 0u;
            m_usSemaphoreCount = 0u;
            m_usPendingReqCount = 0u;
            m_usThreadCount = usThreadCount_i;
            // Create semaphore for thread count management.
            m_hSemaphore = CreateSemaphore( NULL, 0, m_usThreadCount, NULL );
            if( NULL == m_hSemaphore )
            {
                LogError( L"Semaphore creation failed" );
                m_usThreadCount = 0u;
                return false;
            }
            // Create worker threads and make pool active
            if( !AddThreads())
            {
                LogError( L"Threads creation failed" );
                Destroy();
                return false;
            }
            SetDestroyFlag( false );
            LogInfo( L"Thread pool created successfully" );
            return true;
        }
        catch( ... )
        {
            LogError( L"Exception occurred in Create()" );
            return false;
        }
    }


    /** 
     * Destroy thread pool.
     */
    bool ThreadPool::Destroy()
    {
        try
        {
            // Check whether thread pool already destroyed.
            if( NULL == m_phThreadList )
            {
                LogError( L"ThreadPool is already destroyed or not created yet" );
                return false;
            }
            // Cancel all requests.
            CancelRequests();
            // Set destroyed flag to true for exiting threads.
            SetDestroyFlag( true );
            // Release remaining semaphores to exit thread.
            {
                AutoLock LockThread( m_LockWorkerThread );
                if( m_lActiveThread < m_usThreadCount )
                {
                    if( NULL == ReleaseSemaphore( m_hSemaphore, m_usThreadCount - m_lActiveThread, NULL ))
                    {
                        LogError( L"Failed to release Semaphore" );
                        return false;
                    }
                }
            }
            // Wait for destroy completion and clean the thread pool.
            if( !DestroyPool())
            {
                LogError( L"Thread pool destruction failed" );
                return false;
            }
            LogInfo( L"Thread Pool destroyed successfully" );
            return true;
        }
        catch( ... )
        {
            LogError( L"Exception occurred in Destroy()" );
            return false;
        }
    }


    /** 
     * Post request to thread pool for processing
     * 
     * @param       pRequest_io - Request to be processed.
     */
    bool ThreadPool::PostRequest( AbstractRequest* pRequest_io )
    {
        try
        {
            AutoLock LockThread( m_LockWorkerThread );
            if( NULL == m_phThreadList )
            {
                LogError( L"ThreadPool is destroyed or not created yet" );
                return false;
            }
            m_RequestQueue.push_back( pRequest_io );
            if( m_usSemaphoreCount < m_usThreadCount )
            {
                // Thread available to process, so notify thread.
                if( !NotifyThread())
                {
                    LogError( L"NotifyThread failed" );
                    // Request notification failed. Try after some time.
                    m_usPendingReqCount++;
                    return false;
                }
            }
            else
            {
                // Thread not available to process.
                m_usPendingReqCount++;
            }
            return true;
        }
        catch( ... )
        {
            LogError( L"Exception occurred in PostRequest()" );
            return false;
        }
    }


    /** 
     * Pop request from queue for processing.
     * 
     * @param       RequestQueue_io  - Request queue.
     * @return      AbstractRequest* - Request pointer.
     */
    AbstractRequest* ThreadPool::PopRequest( REQUEST_QUEUE& RequestQueue_io )
    {
        AutoLock LockThread( m_LockWorkerThread );
        if( !RequestQueue_io.empty())
        {
            AbstractRequest* pRequest = RequestQueue_io.front();
            RequestQueue_io.remove( pRequest );
            return pRequest;
        }
        return 0;
    }


    /** 
     * Create specified number of threads. Initial status of threads will be waiting.
     */
    bool ThreadPool::AddThreads()
    {
        try
        {
            // Allocate memory for all threads.
            m_phThreadList = new HANDLE[m_usThreadCount];
            if( NULL == m_phThreadList )
            {
                LogError( L"Memory allocation for thread handle failed" );
                return false;
            }
            // Create worker threads.
            DWORD dwThreadID = 0;
            for( unsigned short usIdx = 0u; usIdx < m_usThreadCount; usIdx++ )
            {
                // Create worker thread
                m_phThreadList[usIdx] = CreateThread( 0, 0,
                                                      reinterpret_cast<LPTHREAD_START_ROUTINE>( ThreadPool::ThreadProc ),
                                                      this, 0, &dwThreadID );
                if( NULL == m_phThreadList[usIdx] )
                {
                    LogError( L"CreateThread failed" );
                    return false;
                }
            }
            return true;
        }
        catch( ... )
        {
            LogError( L"Exception occurred in AddThreads()" );
            return false;
        }
    }


    /** 
     * Add request to queue and release semaphore by one.
     */
    bool ThreadPool::NotifyThread()
    {
        try
        {
            AutoLock LockThread( m_LockWorkerThread );
            // Release semaphore by one to process this request.
            if( NULL == ReleaseSemaphore( m_hSemaphore, 1, NULL ))
            {
                LogError( L"ReleaseSemaphore failed" );
                return false;
            }
            m_usSemaphoreCount++;
            return true;
        }
        catch( ... )
        {
            LogError( L"Exception occurred in NotifyThread()" );
            m_RequestQueue.pop_back();
            return false;
        }
    }


    /** 
     * Process request in queue.
     */
    bool ThreadPool::ProcessRequests()
    {
        bool bContinue( true );
        do
        {
            try
            {
                LogInfo( L"Thread WAITING" );
                // Wait for request.
                if( !WaitForRequest())
                {
                    LogError( L"WaitForRequest() failed" );
                    continue;
                }
                // Thread counter.
                AutoCounter Counter( m_lActiveThread, m_LockWorkerThread );
                LogInfo( L"Thread ACTIVE" );
                // Check thread pool destroy request.
                if( IsDestroyed())
                {
                    LogInfo( L"Thread EXITING" );
                    break;
                }
                // Get request from request queue.
                AbstractRequest* pRequest = PopRequest( m_RequestQueue );
                if( NULL == pRequest )
                {
                    LogError( L"PopRequest failed" );
                    continue;
                }
                // Execute the request.
                long lReturn = pRequest->Execute();
                if( NULL != lReturn )
                {
                    LogError( L"Request execution failed" );
                    continue;
                }
                // Check thread pool destroy request.
                if( IsDestroyed())
                {
                    LogInfo( L"Thread EXITING" );
                    break;
                }
                AutoLock LockThread( m_LockWorkerThread );
                // Inform thread if any pending request.
                if( m_usPendingReqCount > 0 )
                {
                    if( m_usSemaphoreCount < m_usThreadCount )
                    {
                        // Thread available to process, so notify thread.
                        if( !NotifyThread())
                        {
                            LogError( L"NotifyThread failed" );
                            continue;
                        }
                        m_usPendingReqCount--;
                    }
                }
            }
            catch( ... )
            {
                LogError( L"Exception occurred in ProcessRequests()" );
                continue;
            }
        }
        while( bContinue );
        return true;
    }


    /** 
     * Wait for request queuing to thread pool.
     */
    bool ThreadPool::WaitForRequest()
    {
        try
        {
            // Wait released when requested queued.
            DWORD dwReturn = WaitForSingleObject( m_hSemaphore, INFINITE );
            if( WAIT_OBJECT_0 != dwReturn )
            {
                LogError( L"WaitForSingleObject failed" );
                return false;
            }
            AutoLock LockThread( m_LockWorkerThread );
            m_usSemaphoreCount--;
            // Clear previous error.
            ::SetLastError( 0 );
            return true;
        }
        catch( ... )
        {
            LogError( L"Exception occurred in WaitForRequest()" );
            return false;
        }
    }


    /** 
     * Destroy and clean up thread pool.
     */
    bool ThreadPool::DestroyPool()
    {
        try
        {
            // Wait for the exist of threads.
            DWORD dwReturn = WaitForMultipleObjects( m_usThreadCount, m_phThreadList, TRUE, INFINITE );
            if( WAIT_OBJECT_0 != dwReturn )
            {
                LogError( L"WaitForMultipleObjects failed" );
                return false;
            }
            // Close all threads.
            for( USHORT uIdx = 0u; uIdx < m_usThreadCount; uIdx++ )
            {
                if( TRUE != CloseHandle( m_phThreadList[uIdx] ))
                {
                    LogError( L"CloseHandle failed for threads" );
                    return false;
                }
            }
            // Clear memory allocated for threads.
            delete[] m_phThreadList;
            m_phThreadList = 0;
            // Close the semaphore
            if( TRUE != CloseHandle( m_hSemaphore ))
            {
                LogError( L"CloseHandle failed for semaphore" );
                return false;
            }
            // Clear request queue.
            m_RequestQueue.clear();
            return true;
        }
        catch( ... )
        {
            LogError( L"Exception occurred in DestroyPool()" );
            return false;
        }
    }


    /** 
     * Check for destroy request.
     */
    inline bool ThreadPool::IsDestroyed()
    {
        // Avoid synchronization issues if destroy requested after validation.
        AutoLock LockThread( m_LockWorkerThread );
        // During thread pool destruction all semaphores are released
        // to exit all threads.
        return m_bDestroyed;
    }


    /** 
     * Set destroy flag
     */
    inline void ThreadPool::SetDestroyFlag( const bool bFlag_i )
    {
        AutoLock LockThread( m_LockWorkerThread );
        m_bDestroyed = bFlag_i;
    }


    /** 
     * Cancel all processing request in pool.
     */
    void ThreadPool::CancelRequests()
    {
        try
        {
            // Avoid synchronization issues if destroy requested after validation.
            AutoLock LockThread( m_LockWorkerThread );
            LogInfo( L"Thread pool destroy requested" );
            // Clear main queue.
            m_RequestQueue.clear();
        }
        catch( ... )
        {
            LogError( L"Exception occurred in CancelRequests()" );
        }
    }


    /** 
     * Log error in thread pool.
     * 
     * @param       wstrError_i - Error description.
     */
    void ThreadPool::LogError( const std::wstring& wstrError_i )
    {
        if( NULL != m_pLogger )
        {
            m_pLogger->LogError( m_lActiveThread, wstrError_i );
        }
    }


    /** 
     * Log information in thread pool.
     * 
     * @param       wstrInfo_i - Information description.
     */
    void ThreadPool::LogInfo( const std::wstring& wstrInfo_i )
    {
        if( NULL != m_pLogger )
        {
            m_pLogger->LogInfo( m_lActiveThread, wstrInfo_i );
        }
    }


    /** 
     * worker thread procedure.
     * 
     * @param       pParam_i - ThreadPool instance.
     * @return      UINT      - Return 0 on success.
     */
    UINT ThreadPool::ThreadProc( LPVOID pParam_i )
    {
        ThreadPool* pThreadPool = NULL;
        try
        {
            ThreadPool* pThreadPool = reinterpret_cast<ThreadPool*>( pParam_i );
            if( NULL == pThreadPool )
            {
                return 1;
            }
            if( !pThreadPool->ProcessRequests())
            {
                pThreadPool->LogError( L"ProcessRequests() failed" );
                return 1;
            }
            return 0;
        }
        catch( ... )
        {
            if( NULL !=  pThreadPool )
            {
                pThreadPool->LogError( L"Exception occurred in ThreadProc()" );
            }
            return 1;
        }
    }
} // namespace TP

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

 *****************************************************************************************************************************************************

英文原文：http://www.codeproject.com/Articles/637708/Thread-Pool

源代码   ：http://files.cnblogs.com/wb-DarkHorse/ThreadPool.zip

 

另外一篇讲线程池的文章：http://www.codeproject.com/Tips/579294/A-Perfect-ThreadPool-in-Windows-Cplusplus