实用线程封装(linux)

#ifndef  __MPDK_DEF_H__
#define  __MPDK_DEF_H__

#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <pthread.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <sys/un.h>
#include <netinet/in.h>
//#include <netinet/sctp.h>
#include <netinet/if_ether.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <netinet/tcp.h>
#include <net/if.h>
#include <netdb.h>
#include <arpa/inet.h> //inet_addr()
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <iconv.h>
#include <ctype.h>
#include <typeinfo>
#include <dirent.h>
#include <stdarg.h>
#include <utility>
#include <assert.h>
#include <errno.h>
#include <stdint.h> //for uint32_t
#include <unistd.h>
/// Public header file reference
#include <string>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <deque>
#include <iostream>
#include <fstream>
#include <cctype>
#include <algorithm>
#include <ext/hash_map>
#include <ext/hash_set>

#ifdef _DEBUG
#include <set>
#endif

using namespace  std;
using namespace  __gnu_cxx;

#define TRUE           1
#define FALSE           0
#define closesocket         close
#define SOCKET_ERROR   -1
#define TRACE                 printf
#define MAX_PATH          260
#define INVALID_SOCKET     -1
#define SOCKET_ERROR        -1

#ifndef NTOHL
#define NTOHL(x) (x) = ntohl(x)
#define NTOHS(x) (x) = ntohs(x)
#define HTONL(x) (x) = htonl(x)
#define HTONS(x) (x) = htons(x)
#endif

#define MPDK_API

#endif // __MPDK_DEF_H__

 

//========================================================================

 

#ifndef   __MPDK_THREAD_H__
#define   __MPDK_THREAD_H__

#include "MPDKDef.h"

namespace MPDK
{
 namespace MPThread
 {
  class CMutex
  {
  public:
   CMutex(void);
   virtual ~CMutex(void);
  public:
   void Lock(void);
   void UnLock(void);
  private:
            pthread_mutex_t m_Mutex;
  };

  class CLock
  {
  public:
   CLock(CMutex& mutex);
   virtual ~CLock(void);
  private:
   CMutex& m_Mutex;
  };

  class CThread
  {
  public:
   CThread(void);
   virtual ~CThread(void);
  public:
   bool   Start(void);
   void   Stop(void);
   bool   IsRunning(void) const;
   static void MsSleep(int nMsec);
  protected:
   void   Run(void);
   void   Destory(void);
   virtual bool  OnStart(void);
   virtual void  OnStop(void);
   virtual void  Execute(void) = 0;
  private:
   static void* ThreadFunc(void* pParam = NULL);
        private:
            bool  m_bRunning;
            pthread_t m_hThread;
  };

  template <typename T>
  class CQueue
  {
  public:
   CQueue(unsigned int uiSize = 30000000);
   virtual ~CQueue(void);
  public:
   inline bool Push(T* e);
   inline bool Pop(T** e);
  private:
   T**  m_pQueue;
   unsigned int m_uiSize;
   unsigned int m_uiPop;
   unsigned int m_uiPush;
   unsigned int m_uiNum;
   CMutex m_Mutex;
  };

  template <typename T>
  bool CQueue<T>::Pop( T** e )
  {
   CLock x(m_Mutex);

   if (!m_uiNum)
   {
    return false;
   }

   if (m_uiPop == m_uiSize)
   {
    m_uiPop = 0;    
   }

   *e = *(m_pQueue + m_uiPop%m_uiSize);

   m_uiPop++;
   m_uiNum--;

   return true;
  }

  template <typename T>
  bool CQueue<T>::Push( T* e )
  {
   CLock x(m_Mutex);

   if (m_uiNum >= m_uiSize)
   {
#ifdef _DEBUG_
    printf("Msg Push fail(e=%lu)...\n", (uint64_t)e);
#endif
    return false;
   }

   if (m_uiPush == m_uiSize)
   {
    m_uiPush = 0;
   }   

   //printf("Msg Push (e=%lu), pos=%lu\n", (uint64_t)e, m_uiPush%m_uiSize);   
   //m_pQueue[m_uiPush%m_uiSize] = e;
   *(m_pQueue + m_uiPush%m_uiSize) = e;
   //printf("Msg Push end(%lu)\n", *(m_pQueue + m_uiPush%m_uiSize));

   m_uiPush++;
   m_uiNum++;

   return true;
  }

  template <typename T>
  CQueue<T>::CQueue( unsigned int uiSize /*= 50000000*/ ) : m_uiSize(uiSize), m_uiPop(0), m_uiPush(0), m_uiNum(0)
  {

   uiSize = uiCount;
   m_uiSize = uiCount;

   m_pQueue = ( new T*[uiSize] );
   assert(m_pQueue);
   // pNode[0] = new CMsg;
   // *(pNode + 3) = new CMsg;
  }

  template <typename T>
  CQueue<T>::~CQueue(void)
  {
   if (m_pQueue)
   {
    delete[] m_pQueue;
    m_pQueue = NULL;
   }
  }
 }
}
#endif // __MPDK_THREAD_H__

 

//========================================================================

#include "thread.h"

namespace MPDK
{
 namespace MPThread
 {
  CMutex::CMutex(void)
  {
   pthread_mutex_init(&m_Mutex,NULL);
  }

  CMutex::~CMutex(void)
  {
   pthread_mutex_destroy(&m_Mutex);
  }

  void CMutex::Lock(void)
  {
   pthread_mutex_lock(&m_Mutex);
  }

  void CMutex::UnLock(void)
  {
   pthread_mutex_unlock(&m_Mutex);
  }

  CLock::CLock(CMutex& mutex):m_Mutex(mutex)
  {
   m_Mutex.Lock();
  }

  CLock::~CLock(void)
  {
   m_Mutex.UnLock();
  }

  CThread::CThread(void) : m_bRunning(false)
  {
  }

  CThread::~CThread(void)
  {
   if (m_bRunning)
   {
    Stop();
   }
  }

  void CThread::Run(void)
  {
   Execute();

   m_bRunning = false;

   Destory();
  }

  void CThread::Destory(void)
  {
   pthread_exit(NULL);
  }

  bool CThread::Start(void)
  {
   if (m_bRunning)
   {
    return false;
   }

   if ( !OnStart() )
   {
    return m_bRunning;
   }

   m_bRunning = true;

   if (pthread_create(&m_hThread, NULL, CThread::ThreadFunc, (void*)this) != 0)
   {
    m_bRunning = false;
    return m_bRunning;
   }

   return m_bRunning;
  }

  void CThread::Stop(void)
  {
   m_bRunning = false;

   OnStop();

   pthread_join(m_hThread,0);
   pthread_cancel(m_hThread);
  }

  bool CThread::IsRunning(void) const
  {
   return m_bRunning;
  }

  void CThread::MsSleep(int nMsec)
  {
   usleep(nMsec * 1000L);
  }

  void* CThread::ThreadFunc(void* pParam)
  {
   CThread* pThread = (CThread*)pParam;
   pthread_detach(pthread_self());

   if ( NULL != pThread )
   {
    pThread->Run();
   }

   return NULL;
  }

  bool CThread::OnStart(void)
  {
   return true;
  }

  void CThread::OnStop(void)
  {
  }
 }
}