一个windows线程类的实现

转载 2016年06月02日 10:48:18

Thread.h

 

  1. #ifndef __THREAD_H__  
  2. #define __THREAD_H__  
  3.   
  4. #include <string>  
  5.   
  6. #include   <windows.h>  
  7. #include   <process.h>  
  8.   
  9. class Runnable  
  10. {  
  11. public:  
  12.     virtual ~Runnable() {};  
  13.     virtual void Run() = 0;  
  14. };  
  15.   
  16. class CThread : public Runnable  
  17. {  
  18. private:  
  19.     explicit CThread(const CThread & rhs);  
  20.   
  21. public:  
  22.     CThread();  
  23.     CThread(Runnable * pRunnable);  
  24.     CThread(const char * ThreadName, Runnable * pRunnable = NULL);  
  25.     CThread(std::string ThreadName, Runnable * pRunnable = NULL);  
  26.     ~CThread(void);  
  27.   
  28.     /** 
  29.       开始运行线程 
  30.       @arg bSuspend 开始运行时是否挂起 
  31.     **/  
  32.     bool Start(bool bSuspend = false);  
  33.   
  34.     /** 
  35.       运行的线程函数,可以使用派生类重写此函数 
  36.     **/  
  37.     virtual void Run();  
  38.   
  39.     /** 
  40.       当前执行此函数线程等待线程结束 
  41.       @arg timeout 等待超时时间,如果为负数,等待无限时长 
  42.     **/  
  43.     void Join(int timeout = -1);  
  44.     /** 
  45.       恢复挂起的线程 
  46.     **/  
  47.     void Resume();  
  48.     /** 
  49.       挂起线程 
  50.     **/  
  51.     void Suspend();  
  52.     /** 
  53.       终止线程的执行 
  54.     **/  
  55.     bool Terminate(unsigned long ExitCode);  
  56.   
  57.     unsigned int GetThreadID();  
  58.     std::string GetThreadName();  
  59.     void SetThreadName(std::string ThreadName);  
  60.     void SetThreadName(const char * ThreadName);  
  61.   
  62. private:  
  63.     static unsigned int WINAPI StaticThreadFunc(void * arg);  
  64.   
  65. private:  
  66.     HANDLE m_handle;  
  67.     Runnable * const m_pRunnable;  
  68.     unsigned int m_ThreadID;  
  69.     std::string m_ThreadName;  
  70.     volatile bool m_bRun;  
  71. };  
  72.   
  73. #endif  

 

 

Thread.cpp

 

  1. #include "Thread.h"  
  2.   
  3. CThread::CThread(void) :   
  4. m_pRunnable(NULL),  
  5. m_bRun(false)  
  6. {  
  7. }  
  8.   
  9. CThread::~CThread(void)  
  10. {  
  11. }  
  12.   
  13. CThread::CThread(Runnable * pRunnable) :   
  14. m_ThreadName(""),  
  15. m_pRunnable(pRunnable),  
  16. m_bRun(false)  
  17. {  
  18. }  
  19.   
  20. CThread::CThread(const char * ThreadName, Runnable * pRunnable) :   
  21. m_ThreadName(ThreadName),  
  22. m_pRunnable(pRunnable),  
  23. m_bRun(false)  
  24. {  
  25. }  
  26.   
  27. CThread::CThread(std::string ThreadName, Runnable * pRunnable) :   
  28. m_ThreadName(ThreadName),  
  29. m_pRunnable(pRunnable),  
  30. m_bRun(false)  
  31. {  
  32. }  
  33.   
  34. bool CThread::Start(bool bSuspend)  
  35. {  
  36.     if(m_bRun)  
  37.     {  
  38.         return true;  
  39.     }  
  40.     if(bSuspend)  
  41.     {  
  42.         m_handle = (HANDLE)_beginthreadex(NULL, 0, StaticThreadFunc, this, CREATE_SUSPENDED, &m_ThreadID);  
  43.     }  
  44.     else  
  45.     {  
  46.         m_handle = (HANDLE)_beginthreadex(NULL, 0, StaticThreadFunc, this, 0, &m_ThreadID);  
  47.     }  
  48.     m_bRun = (NULL != m_handle);  
  49.     return m_bRun;  
  50. }  
  51.   
  52. void CThread::Run()  
  53. {  
  54.     if(!m_bRun)  
  55.     {  
  56.         return;  
  57.     }  
  58.     if(NULL != m_pRunnable)  
  59.     {  
  60.         m_pRunnable->Run();  
  61.     }  
  62.     m_bRun = false;  
  63. }  
  64.   
  65. void CThread::Join(int timeout)  
  66. {  
  67.     if(NULL == m_handle || !m_bRun)  
  68.     {  
  69.         return;  
  70.     }  
  71.     if(timeout <= 0)  
  72.     {  
  73.         timeout = INFINITE;  
  74.     }  
  75.     ::WaitForSingleObject(m_handle, timeout);  
  76. }  
  77.   
  78. void CThread::Resume()  
  79. {  
  80.     if(NULL == m_handle || !m_bRun)  
  81.     {  
  82.         return;  
  83.     }  
  84.     ::ResumeThread(m_handle);  
  85. }  
  86.   
  87. void CThread::Suspend()  
  88. {  
  89.     if(NULL == m_handle || !m_bRun)  
  90.     {  
  91.         return;  
  92.     }  
  93.     ::SuspendThread(m_handle);  
  94. }  
  95.   
  96. bool CThread::Terminate(unsigned long ExitCode)  
  97. {  
  98.     if(NULL == m_handle || !m_bRun)  
  99.     {  
  100.         return true;  
  101.     }  
  102.     if(::TerminateThread(m_handle, ExitCode))  
  103.     {  
  104.         ::CloseHandle(m_handle);  
  105.         return true;  
  106.     }  
  107.     return false;  
  108. }  
  109.   
  110. unsigned int CThread::GetThreadID()  
  111. {  
  112.     return m_ThreadID;  
  113. }  
  114.   
  115. std::string CThread::GetThreadName()  
  116. {  
  117.     return m_ThreadName;  
  118. }  
  119.   
  120. void CThread::SetThreadName(std::string ThreadName)  
  121. {  
  122.     m_ThreadName = ThreadName;  
  123. }  
  124.   
  125. void CThread::SetThreadName(const char * ThreadName)  
  126. {  
  127.     if(NULL == ThreadName)  
  128.     {  
  129.         m_ThreadName = "";  
  130.     }  
  131.     else  
  132.     {  
  133.         m_ThreadName = ThreadName;  
  134.     }  
  135. }  
  136.   
  137. unsigned int CThread::StaticThreadFunc(void * arg)  
  138. {  
  139.     CThread * pThread = (CThread *)arg;  
  140.     pThread->Run();  
  141.     return 0;  
  142. }  

 

 

用法:

#include "Thread.h"
#include "ThreadPoolExecutor.h"

class R : public Runnable
{
public:
    ~R()
    {
        printf("~R/n");
    }
    void Run()
    {
        printf("Hello World/n");
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    R r;
    CThread * t = NULL;
    t = new CThread(&r);
    t->Start();
    t->Join();

    getchar();

}

 

from:http://blog.csdn.net/huyiyang2010/article/details/5801597

简单的C++线程类实现, windows平台

一个抽象的线程基类, 再来个具体的线程类并实现相关接口,再写个主函数来调用下。上代码: Thread.h /* Windows平台线程类实现 开发环境: Win7_x64 + VC2012...

windows编程之线程操作

我们知道,进程是资源分配的最小单位,而线程呢,则是CPU运行的最小单位。 在最早的DOS系统下,CPU每次只能运行一个进程且该进程只有一个线程,当该进程执行完退出后,CPU 才能加载另外一个进程。而现...
  • Timmiy
  • Timmiy
  • 2016年07月04日 23:39
  • 1535

Windows线程生灭

一、线程创建 Windows线程在创建时会首先创建一个线程内核对象,它是一个较小的数据结构,操作系统通过它来管理线程。新线程可以访问进程内核对象的所有句柄、进程中的所有内存及同一进程中其它线程的栈。...

windows多线程详解

在一个牛人的博客上看到了这篇文章,所以就转过来了,地址是http://blog.csdn.net/morewindows/article/details/7421759 本文将带领你与多线程作第一次...

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

MFC架构之CWinThread类

      我们知道,Windows以事件驱动方式工作,每个WIN32应用程序都至少包含一个消息队列和一个消息泵。消息队列建立在操作系统提供的内存保留区中,消息泵不断搜寻消息队列,将取得的消息分发给应...

跨平台的线程封装类

#ifdef WIN32 #include #include #else #include #endif /* #ifdef WIN32 typedef unsigned int(__stdc...

一个Windows C++的线程类实现

Thread.h#ifndef __THREAD_H__ #define __THREAD_H__ #include #include #include class Runna...

CWinThread::Run() 简单理解

MFC的控制中心――CWinThread::Run()     说CWinThread:: Run()是MFC的控制中心,一点也没有夸大。在MFC中,所有来自于消息队列的消息的分派...

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:一个windows线程类的实现
举报原因:
原因补充:

(最多只允许输入30个字)