Un Thread di Classe

Grazie alla potenza di calcolo dei processori moderni e vista la crescente complessità delle applicazioni, non si può evitare l'utilizzo dei Thread...

Ovviamente i linguaggi di sviluppo moderni come C# o Java mettono a disposizione del programmatore costrutti semplici e potenti per utilizzare i thread, ma il buon vecchio C++ è decisamente più spartano.

Molti programmatori preferiscono usare i thread "grezzi", ma, a mio parere, questo si traduce in attività complesse ad alto rischio di bug.

La classe che segue incapsula la complessità legata alla creazione ed utilizzo dei thread, consentendo allo sviluppatore di concentrarsi solo sulle azioni che devono essere eseguite nel contesto del Thread.

Questa classe va utilizzata come base per la definizione di thread specializzati: è sufficiente fornire un'implementazione per la funzione OnExecute().

Grazie al supporto di StartUpProc, ExecuteProc, CleanUpProc, con un po' di fantasia, è possibile sviluppare thread anche molto complessi: Buon divertimento ;-).

CustomThread.h

#ifndef __CUSTOMTHREADS_H__
#define __CUSTOMTHREADS_H__

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


typedef UINT (*StartUpProc) (LPVOID pProcParam);
typedef UINT (*ExecuteProc) (LPVOID pProcParam);
typedef UINT (*CleanUpProc) (LPVOID pProcParam);

enum ThreadType
{
  ttNormal  = 0, // Use _beginthreadex / _endthreadex
  ttRaw     = 1, // Use CreateThread / ExitThread
  ttAfxSafe = 2  // Use AfxBeginThread / AfxEndThread
};

enum ThreadPriority
{
  atpTimeCritical = THREAD_PRIORITY_TIME_CRITICAL, //Indicates 3 points above normal priority. 
  atpHighest      = THREAD_PRIORITY_HIGHEST,       //Indicates 2 points above normal priority. 
  atpAboveNormal  = THREAD_PRIORITY_ABOVE_NORMAL,  //Indicates 1 point above normal priority. 
  atpNormal       = THREAD_PRIORITY_NORMAL,        //Indicates normal priority. 
  atpBelowNormal  = THREAD_PRIORITY_BELOW_NORMAL,  //Indicates 1 point below normal priority. 
  atpLowest       = THREAD_PRIORITY_LOWEST,        //Indicates 2 points below normal priority. 
  atpIdle         = THREAD_PRIORITY_IDLE,          //Indicates 4 points below normal priority. 
};

class CCustomThread
{
private:
  static UINT APIENTRY ThreadProc(LPVOID pParam);

private:
  CWinThread *m_WinThread;

  ThreadType m_ThreadType;
  DWORD      m_dwID;
  HANDLE     m_hThread;
  BOOL       m_bSuspended;

protected:
  StartUpProc m_pStartProc;
  ExecuteProc m_pExecProc;
  CleanUpProc m_pCleanProc;
  LPVOID m_pProcParam;

protected:
  HANDLE m_hEvtAskToDie;
  virtual BOOL OnStartUp();     // If return FALSE, Thread Loop doesn't Start
  virtual BOOL OnExecute() = 0; // If return FALSE, Thread Loop will Terminate
  virtual void OnCleanUp();
  
public:
  CCustomThread();
  virtual ~CCustomThread();

  virtual BOOL Init(ThreadType tType = ttNormal);
  virtual BOOL Init(ExecuteProc pExecProc, LPVOID pProcParam, ThreadType tType = ttNormal);
  virtual BOOL Init(StartUpProc pStartProc, ExecuteProc pExecProc, CleanUpProc pCleanProc, LPVOID pProcParam, ThreadType tType = ttNormal);

  virtual BOOL Start();
  virtual BOOL Terminate(int nTimeOut = INFINITE, BOOL bForce = FALSE);

  BOOL SetPriority(ThreadPriority tpPriority);
  BOOL Suspend();
  BOOL Resume();

public:
  inline DWORD ID()       { return m_dwID; }
  inline HANDLE Handle()  { return m_hThread; }
  inline BOOL Started()   { return (m_hThread != NULL); }
  inline BOOL Suspended() { return m_bSuspended; }
};

#endif

CustomThread.cpp

#include "stdafx.h"
#include "CustomThreads.h"

#include <assert.h>
#include <process.h> // required by _beginthreadex and _endthreadex

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


CCustomThread::CCustomThread()
{
  m_ThreadType = ttNormal;
  m_dwID = 0;
  m_hThread = NULL;
  m_bSuspended = TRUE;

  m_pStartProc = NULL;
  m_pExecProc = NULL;
  m_pCleanProc = NULL;

  m_hEvtAskToDie = CreateEvent(NULL, FALSE, FALSE, NULL);
  assert(m_hEvtAskToDie);
}

CCustomThread::~CCustomThread()
{
  Terminate(100, TRUE);
  CloseHandle(m_hEvtAskToDie);
}

UINT APIENTRY CCustomThread::ThreadProc(LPVOID pProcParam)
{
  assert(pProcParam);

  CCustomThread* pThread = reinterpret_cast<CCustomThread*>(pProcParam);

  TRACE(_T("\nThreadProc TH: 0x%X\n"), pThread->m_dwID); // GetID()

  BOOL bStart = FALSE;

  // Call Initialization Routine
  try 
  { 
    bStart = pThread->OnStartUp(); 
  } 
  catch(...) {}

  // Enter Thread Loop...
  while (bStart)
  {
    if (WaitForSingleObject(pThread->m_hEvtAskToDie, 0) == WAIT_OBJECT_0) break;
    
    try { if (!pThread->OnExecute()) break;  } catch(...) { break; }
  }

  try 
  { 
    pThread->OnCleanUp(); 
  } 
  catch(...) {}

  switch (pThread->m_ThreadType)
  {
    case ttNormal:  _endthreadex(0);  break;
    case ttRaw:    ExitThread(0);    break;
    case ttAfxSafe:  AfxEndThread(0);  break;
  }

  return 0;
}

BOOL CCustomThread::OnStartUp()
{
  if (m_pStartProc)
    return ((*m_pStartProc)(m_pProcParam) == 0);
  else  
    return TRUE;
}

void CCustomThread::OnCleanUp()
{
  if (m_pCleanProc)
    (*m_pCleanProc)(m_pProcParam);
}

BOOL CCustomThread::Init(ThreadType tType)
{
  TRACE(_T("\nInit TH: 0x%X\n"), ID());
  m_ThreadType = tType;
  
  return TRUE;
}

BOOL CCustomThread::Init(StartUpProc pStartProc, ExecuteProc pExecProc, CleanUpProc pCleanProc, LPVOID pProcParam, ThreadType tType)
{ 
  if (Started()) return FALSE; // If Started can't Init

  if (!pExecProc) return FALSE; // Invalid Parameters

  BOOL bRet = Init(tType);

  m_pStartProc = pStartProc;
  m_pExecProc = pExecProc; 
  m_pCleanProc = pCleanProc;

  m_pProcParam = pProcParam; 
  
  return bRet;
}

BOOL CCustomThread::Init(ExecuteProc pExecProc, LPVOID pProcParam, ThreadType tType)
{ 
  return Init(NULL, pExecProc, NULL, pProcParam, tType);
}

BOOL CCustomThread::Start()
{
  TRACE(_T("Start Thread\n"));

  if (!m_hThread) // If not Already Started...
  {  
    m_bSuspended = FALSE;

    switch (m_ThreadType)
    {
      case ttNormal:
        m_hThread = (HANDLE)_beginthreadex(NULL, NULL, ThreadProc, this, 0, (UINT*)&m_dwID);
      break;

      case ttRaw:
        m_hThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)ThreadProc, this, 0, &m_dwID);
      break;
      
      case ttAfxSafe:
        m_WinThread = AfxBeginThread((AFX_THREADPROC)ThreadProc, this, THREAD_PRIORITY_NORMAL, 0, 0);
        m_hThread = m_WinThread->m_hThread;
        m_dwID = m_WinThread->m_nThreadID;
      break;
    }    

    TRACE(_T("\nThread Started TH: 0x%X\n"), m_dwID);
  }

  return (m_hThread != NULL);
}  

BOOL CCustomThread::SetPriority(ThreadPriority tpPriority)
{
  if (!m_hThread) return FALSE;

  return SetThreadPriority(m_hThread, (int)tpPriority) != 0;
}

BOOL CCustomThread::Suspend()
{
  TRACE(_T("\nSuspend TH: 0x%X\n"), m_dwID);

  if (!m_hThread) return FALSE; // If Not Started there is nothing to suspend

  if (!m_bSuspended) 
  {
    if (m_ThreadType == ttAfxSafe)
      m_bSuspended = (m_WinThread->SuspendThread() != -1);
    else
      m_bSuspended = (SuspendThread(m_hThread) != -1);
  }
  return m_bSuspended;
}

BOOL CCustomThread::Resume()
{
  TRACE(_T("\nResume TH: 0x%X\n"), m_dwID);

  if (!m_hThread) return FALSE; // If Not Started there is nothing to resume

  if (m_bSuspended)
  {
    if (m_ThreadType == ttAfxSafe)
      m_bSuspended = !(m_WinThread->ResumeThread() != -1);
    else
      m_bSuspended = !(ResumeThread(m_hThread) != -1);
  }

  return !m_bSuspended;
}

BOOL CCustomThread::Terminate(int nTimeOut, BOOL bForce)
{
  if (!m_hThread) return TRUE;  // If Not Started there is nothing to terminate
  
  TRACE(_T("\nTerminate TH: 0x%X\n"), m_dwID);

  ResumeThread(m_hThread);    // Ensure Thread is Running

  SetEvent(m_hEvtAskToDie);    // Signal AskToDie Event
  
  if (WaitForSingleObject(m_hThread, nTimeOut) == WAIT_TIMEOUT) // Die Hard Thread...
  {
    if (!bForce) return FALSE;

    ResetEvent(m_hEvtAskToDie);    // Reset AskToDie Event
    
    TRACE(_T("\nDie Hard Thread TH: 0x%X\n"), m_dwID);
    DWORD dwExitCode = -1;

    if (!GetExitCodeThread(m_hThread, &dwExitCode))  
    {
      TRACE(_T("\nFailed to Get Exit Code TH: 0x%X\n"), m_dwID);
      return FALSE;
    }

    if (m_ThreadType != ttAfxSafe)
      if (!TerminateThread(m_hThread, dwExitCode))
      {
        TRACE(_T("\nFailed to Terminate Thread TH: 0x%X\n"), m_dwID);
        return FALSE;
      }
  }

  if (m_ThreadType != ttAfxSafe)
    CloseHandle(m_hThread);

  m_hThread = NULL;
  m_dwID = 0;
  m_bSuspended = FALSE;
  
  return TRUE;
}

Tutte le Utility