#ifndef _THREAD_POOL_H_

#define _THREAD_POOL_H_

 

#include <windows.h>

#include <process.h>

 

#pragma once

 

typedef void (* ThreadPoolProc) (void* lpParam);

 

struct ThreadData;

 

class ThreadPool

{

public:

  explicit ThreadPool(int size /*0<size<65*/);

  ~ThreadPool();

 

  bool work();

  void AddWorkerItem(ThreadPoolProc pfn, void* lp);

 

protected:

  virtual unsigned int Run();

 

private:

  ThreadPool(const ThreadPool& other);

  ThreadPool& operator= (const ThreadPool& rbs);

 

  static unsigned int _stdcall __ThreadPoolProc (void* lpParam);

 

protected:

  bool m_bCompleted;

 

  HANDLE* m_pThreads;

  int m_nSize;

 

  HANDLE m_hFull;

  HANDLE m_hEmpty;

  HANDLE m_hLock;

 

  ThreadData** m_pTDPool;

  int m_nPoolSize;

  int m_indexp;

  int m_indexc;

};

 

#endif

 

---

#include "ThreadPool.h"

 

struct ThreadData

{

  ThreadPoolProc m_pfnProc;

  void* m_lpParam;

};

 

ThreadPool::ThreadPool(int size)

{

  m_bCompleted=false;

  m_nSize=size;

  m_nPoolSize=size<<1;

 

  m_pThreads=NULL;

  m_pTDPool=NULL;

 

  m_hFull=NULL;

  m_hEmpty=NULL;

  m_hLock=NULL;

 

  m_indexp=m_indexc=0;

}

 

ThreadPool::~ThreadPool()

{

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

  {

     ::TerminateThread(m_pThreads[i], 0);

     ::CloseHandle(m_pThreads[i]);

  }

  delete[] m_pThreads;

  ::CloseHandle(m_hFull);

  ::CloseHandle(m_hEmpty);

  ::CloseHandle(m_hLock);

  delete[] m_pTDPool;

}

 

bool ThreadPool::work()

{

  bool ret=true;

 

  if ( m_bCompleted )

     return ret=false;

 

  if ( m_nSize<1 || m_nSize>64 )

     ret=false;

  else

  {

     m_pThreads=new HANDLE[m_nSize];

     if ( m_pThreads==NULL )

       ret=false;

     else

     {

       ZeroMemory(m_pThreads, sizeof(HANDLE)*m_nSize);

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

       {

         m_pThreads[i]=(HANDLE)_beginthreadex(NULL, 0, ThreadPool::__ThreadPoolProc, this, CREATE_SUSPENDED, NULL);

         if ( m_pThreads[i]==NULL )

         {

            ret=false;

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

              ::CloseHandle(m_pThreads[j]);

            delete[] m_pThreads;

            return ret;

         }

       }

       m_pTDPool=new ThreadData*[m_nPoolSize];

       if ( m_pTDPool==NULL )

       {

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

            ::CloseHandle(m_pThreads[i]);

         delete[] m_pThreads;

         ret=false;

         return ret;

       }

       else

       {

         ZeroMemory(m_pTDPool, sizeof(ThreadData*)*m_nPoolSize);

         m_hFull=::CreateSemaphore(NULL, m_nPoolSize, m_nPoolSize, NULL);

         if ( m_hFull==NULL )

            ret=false;

         else

         {

            m_hEmpty=::CreateSemaphore(NULL, 0, m_nPoolSize, NULL);

            if ( m_hEmpty==NULL )

              ret=false;

            else

            {

              m_hLock=::CreateMutex(NULL, FALSE, NULL);

              if ( m_hLock==NULL )

                ret=false;

            }

         }

         if ( !ret )

         {

            if ( m_hFull!=NULL )

              ::CloseHandle(m_hFull);

            if ( m_hEmpty!=NULL )

              ::CloseHandle(m_hEmpty);

            delete[] m_pTDPool;

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

              ::CloseHandle(m_pThreads[i]);

            delete[] m_pThreads;

         }

         else

         {

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

              ::ResumeThread(m_pThreads[i]);

            m_bCompleted=true;

         }

       }

     }

  }

  return ret;

}

 

unsigned int _stdcall ThreadPool::__ThreadPoolProc(void *lpParam)

{

  ThreadPool* ptp=(ThreadPool*)lpParam;

  return ptp->Run();

}

 

unsigned int ThreadPool::Run()

{

  ThreadData* p=NULL;

  for ( ; ; )

  {

     ::WaitForSingleObject(m_hEmpty, INFINITE);

     ::WaitForSingleObject(m_hLock, INFINITE);

     p=m_pTDPool[m_indexc];

     m_pTDPool[m_indexc]=NULL;

     m_indexc=(m_indexc+1)%m_nPoolSize;

     ::ReleaseMutex(m_hLock);

     ::ReleaseSemaphore(m_hFull, 1, NULL);

     p->m_pfnProc(p->m_lpParam);

     delete p;

  }

}

 

void ThreadPool::AddWorkerItem(ThreadPoolProc pfn, void *lp)

{

  if ( m_bCompleted )

  {

     ThreadData* p=new ThreadData;

     p->m_lpParam=lp;

     p->m_pfnProc=pfn;

     ::WaitForSingleObject(m_hFull, INFINITE);

     ::WaitForSingleObject(m_hLock, INFINITE);

     m_pTDPool[m_indexp]=p;

     m_indexp=(m_indexp+1)%m_nPoolSize;

     ::ReleaseMutex(m_hLock);

     ::ReleaseSemaphore(m_hEmpty, 1, NULL);

  }

}

发表于 @ 2009年04月03日　15:21:00 | 评论( loading... ) | 编辑| 举报| 收藏

旧一篇:散列技术与策略设计 | 新一篇:大整数类（代码）