C++ 自动唤醒线程

在通常的程序设计中,我们时常会不断地启动新线程来完成不断出现的新任务.而由于任务的大小不确定性,以及出现要处理的任务的时间的不确定性,使得我们的好多程序总是在不断地在开启线程,并完成某任务后就退出线程.当每次任务不大,可又总是有任务频繁出现时,总是不断地开启并退出线程.这开启并退出线程所消耗的系统资源与用线程机制所带来的收效是不合理的,而且通常我们的任务一般也正如上所述,通常不大,而且时不时会有出现要处理.这时我们就需要一个能自动唤醒的线程来处理我们的这些小而多又很杂的任务.现分享一C++实现的源码与大家交流学习.

 

// Thread.h
#ifndef __THREAD_H_
#define __THREAD_H_

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

#pragma once

#define STOP_WORKING -1
#define KEEP_WORKING  0
#define RUN_EORKING   1

class CThTarget 
{ 
public:
 CThTarget()
 {
  m_autoDeleteFlag = true;
  m_nData = 0;
 }

 virtual ~CThTarget()
 {
 }
 
 bool AutoDelete()
 {
  return m_autoDeleteFlag;
 }
 void setAutoDelete(bool autoDeleteFlag = true)
 {
  m_autoDeleteFlag = autoDeleteFlag;
 }

 void setData(int nData)
 {
  m_nData = nData;
 }

 virtual void run()
 {
  printf("RUN THREAD ./n");
  printf("RUN %d./n", m_nData);
 }
 
private:
 bool m_autoDeleteFlag;
 int  m_nData;
};

class CThread
{
public:
 CThread()
 {
  m_flag = KEEP_WORKING;
  InitializeCriticalSection(&m_csThread);
  m_hThread = (HANDLE)_beginthreadex( NULL, 0, &ThreadFunction
           , this, 0, &m_unThreadID );
 }

 virtual ~CThread()
 {
  if(m_hThread != NULL )
  {
   CloseHandle(m_hThread) ;
  }
  DeleteCriticalSection(&m_csThread);
 }
 
 static unsigned __stdcall ThreadFunction(void* pParam)
 {
  CThread *pThread = (CThread *)pParam;
  pThread->m_flag = RUN_EORKING;

  while(pThread->m_flag != STOP_WORKING )
  {
   //Do the work if the target is not null;
   while(pThread->m_tlTask.size() !=  0)
   {
    CThTarget* pTarget = NULL;
    EnterCriticalSection(&pThread->m_csThread);
    pTarget = pThread->m_tlTask.front();
    pThread->m_tlTask.remove(pTarget);
    LeaveCriticalSection(&pThread->m_csThread);
    pTarget->run();
    //If auto delete set in the target then destroy the target
    if(pTarget->AutoDelete())
     delete pTarget;   
    pTarget = NULL;   
   }
   pThread->m_flag = KEEP_WORKING;
   printf("SuspendThread./n");
   SuspendThread(pThread->m_hThread); 
  }
  return 0;
 }
 
 void setTarget(CThTarget *pTarget)
 {  
  EnterCriticalSection(&m_csThread);
  m_tlTask.push_back(pTarget);
  LeaveCriticalSection(&m_csThread);
  printf("ResumeThread./n");
  ResumeThread(m_hThread);
 }

 CThTarget* getTarget(void)
 {
  if(m_tlTask.size() == 0)
   return NULL;
  
  CThTarget* pTarget = NULL;
  
  EnterCriticalSection(&m_csThread);
  pTarget = m_tlTask.front();
  m_tlTask.remove(pTarget);
  LeaveCriticalSection(&m_csThread);
  
  return pTarget;
 }

 bool isFree()
 {
  if(m_tlTask.size() == 0)
  {
   return true;
  }
  else
  {
   return false;
  }
 }

 void stop()
 {
  m_flag = STOP_WORKING;
  ResumeThread(m_hThread);
 }

private:
 int     m_flag;    // 线程状态
 typedef std::list<CThTarget*> TargetList;
 typedef TargetList::iterator TargetListIter;
 TargetList   m_tlTask;    // 任务列表
 unsigned   m_unThreadID;   // 线程ID
 CRITICAL_SECTION m_csThread;   // 临界区对像
 HANDLE    m_hThread;    // 线程句柄
};

#endif