线程管理 就是这么简单

最新推荐文章于 2024-05-31 23:18:48 发布
置顶 最新推荐文章于 2024-05-31 23:18:48 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 技术 文章标签： command null callback winapi class delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenyanxu/article/details/2189289
版权

首先，我想应该先了解一下什么是线程，操作系统里说线程是系统可以管理的最小的单元，线程管理里--操作系统控制着他的CPU使用；而我们抛开系统的概念，线程又是什么呢？线程是一系列可以独立执行的指令的堆栈，我们自己控制着代码的执行，这就是为什么线程函数里都要有一个循环的原因，只不过为了更好的利用硬件的资源，我们引入了系统的概念，而多线程就是多套相互独立的指令堆栈，如果没有系统的管理线程的代码也是可以单独执行的，系统的最重要的工作是保护好线程堆栈的现场。

面向对象的方法让我们很好的管理资源，所有设计到系统内核的资源，我们都有可能忘掉还给系统的时候，这时候就会出现系统资源的浪费，自从OO方法的出现就引入了利用对象来管理资源的方法，微软在MFC已经采用了这样的方法，但微软的方法太臃肿（个人认为i），在.NET平台推出以后更是这样；在LINIUX上也有很多这样的类库的代码。

下面是我个人写的一个类库，利用这个库可以很好的管理线程资源。

/************************************************************************

  * 版权所有 (C)2008, 陈彦旭。
  *
  * 文件名称： MyThread.h
  * 内容摘要： 线程资源管理和使用
  * 其它说明：
  * 当前版本： 1.0.0.0
  * 作    者： 陈彦旭
  * 完成日期： 2008年01月20日
 
************************************************************************/


#if !defined(AFX_MYTHREAD_H__D97FB306_0742_43F7_8574_581DB0FBE538__INCLUDED_)
#define AFX_MYTHREAD_H__D97FB306_0742_43F7_8574_581DB0FBE538__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
//#include <Thread.h>
#include <process.h>

#include "MyMutex.h"

class CMyThread 
{
public:
 CMyThread();
 virtual ~CMyThread();

public:
 static DWORD WINAPI ThreadFunc(LPVOID pParam);

public:
 virtual BOOL AfterWork();
 virtual BOOL Work();
 virtual BOOL BeforeWork();
public:
 BOOL IsRun();
 BOOL IsPause();
 BOOL IsSuspend();
 BOOL IsExit();
 BOOL SetExitState( BOOL bState );
 BOOL SetRunState( BOOL bState );
 BOOL SetPauseState( BOOL bState );
 BOOL SetSuspendState( BOOL bState );
public:
 BOOL RunThread();
 BOOL StopThread( DWORD dwDelayTime=2000 );
 
 BOOL SuspendThread();
 BOOL ResumeThread();
 
 void SetThreadName(CString sThreadName=_T(""));
 CString GetThreadName();
 
 HANDLE GetThreadHandle();
 DWORD GetThreadID();
 BOOL CloseThread();

private:
 BOOL m_bRun;
 BOOL m_bPause;
 BOOL m_bExit;
 BOOL m_bSuspend;
 CString m_sThreadName;

 CMyMutex m_RunMutex;
 CMyMutex m_PauseMutex;
 CMyMutex m_ExitMutex;
 CMyMutex m_SuspendMutex;

 HANDLE  m_hThread;
 DWORD  m_dwThreadId;
};

#endif // !defined(AFX_MYTHREAD_H__D97FB306_0742_43F7_8574_581DB0FBE538__INCLUDED_)
// MyThread.cpp: implementation of the CMyThread class.
//
//

#include "stdafx.h"
#include "MyThread.h"

//
// Construction/Destruction
//

typedef unsigned (__stdcall *PTHREAD_START) (void *);
#define chBEGINTHREADEX(psa, cbStack, pfnStartAddr, /
 pvParam, fdwCreate, pdwThreadID)                /
 ((HANDLE) _beginthreadex(                       /
 (void *) (psa),                                 /
 (unsigned) (cbStack),                           /
 (PTHREAD_START) (pfnStartAddr),                 /
 (void *) (pvParam),                             /
 (unsigned) (fdwCreate),                         /
 (unsigned *) (pdwThreadID)))


CMyThread::CMyThread()
{
 m_bRun   = FALSE;
 m_bPause  = FALSE;
 m_bExit   = FALSE;
 m_bSuspend  = FALSE;
 
 m_sThreadName = _T("");
 m_hThread  = NULL;
 m_dwThreadId = 0;
}

CMyThread::~CMyThread()
{

}


BOOL CMyThread::AfterWork()
{
 return TRUE;
}

BOOL CMyThread::Work()
{
 return TRUE;
}

BOOL CMyThread::BeforeWork()
{
 return TRUE;
}

BOOL CMyThread::IsRun()
{
 CUseMutex mutex(&this->m_RunMutex);
 return this->m_bRun;
}

BOOL CMyThread::IsPause()
{
 CUseMutex mutex(&this->m_PauseMutex);
 return this->m_bPause;
}

BOOL CMyThread::IsSuspend()
{
 CUseMutex mutex(&this->m_SuspendMutex);
 return this->m_bSuspend;
}

BOOL CMyThread::IsExit()
{
 CUseMutex mutex(&this->m_ExitMutex);
 return this->m_bExit;
}

BOOL CMyThread::SetExitState( BOOL bState )
{
 CUseMutex mutex(&this->m_ExitMutex);
 this->m_bExit = bState;
 return TRUE;
}

BOOL CMyThread::SetRunState( BOOL bState )
{
 CUseMutex mutex(&this->m_RunMutex);
 this->m_bRun = bState;
 return TRUE;
}

BOOL CMyThread::SetPauseState( BOOL bState )
{
 CUseMutex mutex(&this->m_PauseMutex);
 this->m_bPause = bState;
 return TRUE;
}
BOOL CMyThread::SetSuspendState( BOOL bState )
{
 CUseMutex mutex(&this->m_SuspendMutex);
 this->m_bSuspend = bState;
 return TRUE;
}

BOOL CMyThread::RunThread()
{
 if (IsRun())
  return TRUE;

 this->SetExitState(FALSE);
 this->SetPauseState(FALSE);
 this->SetSuspendState(FALSE);

 this->m_hThread = chBEGINTHREADEX( NULL, 0, CMyThread::ThreadFunc, (void*)this, 0, &this->m_dwThreadId);

 if (NULL == this->m_hThread)
 { 
  WQFTRACE("%s线程创建失败errorno=%d /n", this->m_sThreadName, ::GetLastError());  
  return FALSE;
 }
 
 this->SetRunState(TRUE);

 return TRUE;
}

DWORD WINAPI CMyThread::ThreadFunc(LPVOID pParam)
{
 CMyThread* pThread = (CMyThread*)pParam;

 if (!pThread->m_hThread)
 { 
  WQFTRACE("%s线程句柄已失效! /n", pThread->m_sThreadName);
  pThread->AfterWork();
  pThread->SetRunState(FALSE);
  return 0;

 }
 
 if (!pThread->BeforeWork())
 {
  pThread->SetRunState(FALSE);
  pThread->AfterWork();
  return 0;
 }

 while (!pThread->IsExit())
 {
  if (pThread->IsPause())
  {
   Sleep(1);
  }
  else
  {
   if (!pThread->Work())
    break;
  }
 }
 pThread->AfterWork();
 pThread->SetRunState(FALSE);
 return 0;
}

BOOL CMyThread::StopThread( DWORD dwDelayTime )
{
 this->SetExitState(FALSE);
 
 DWORD dwTime = ::timeGetTime();
 while ((::timeGetTime()-dwTime) < dwDelayTime)
 {
  if (!this->IsRun())
  { 
   return TRUE;
  }
  Sleep(10);
 }

 if (this->m_hThread)
 {  
  static DWORD g_ThreadTerminateCount=0;
  if (::TerminateThread(this->m_hThread, ++g_ThreadTerminateCount))
  {
   WQFTRACE("**********强制退出%s线程! /n", this->m_sThreadName);
   WQFASSERT(FALSE);
  }
 }

 this->CloseThread();
 return TRUE;
}

BOOL CMyThread::SuspendThread()
{
 return TRUE;
}

BOOL CMyThread::ResumeThread()
{
 return TRUE;
}

void CMyThread::SetThreadName(CString sThreadName)
{
}

CString CMyThread::GetThreadName()
{
 return this->m_sThreadName;
}

HANDLE CMyThread::GetThreadHandle()
{
 return this->m_hThread;
}

DWORD CMyThread::GetThreadID()
{
 return this->m_dwThreadId;
}

BOOL CMyThread::CloseThread()
{
 if (this->m_hThread)
 {
  ::CloseHandle(this->m_hThread);
  this->m_hThread = NULL;
  this->m_dwThreadId = 0;
 }
 return TRUE;
}
/************************************************************************

  * 版权所有 (C)2008, 陈彦旭。
  *
  * 文件名称： MyProcess.h
  * 内容摘要： 线程资源管理和使用
  * 其它说明：
  * 当前版本： 1.0.0.0
  * 作    者： 陈彦旭
  * 完成日期： 2008年01月20日
 
************************************************************************/


#if !defined(AFX_MYPROCESS_H__F958678E_5978_421D_BE7E_56D6266DE6FB__INCLUDED_)
#define AFX_MYPROCESS_H__F958678E_5978_421D_BE7E_56D6266DE6FB__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
typedef BOOL (*ProcessCallback)(LPVOID lpUser, DWORD dwCommand, LPVOID lpData);
#include "MyThread.h"

typedef enum {

 PROCESS_COMMAND_BEFORE,
 PROCESS_COMMAND_PROCESS,
 PROCESS_COMMAND_AFTER,
 PROCESS_COMMAND_DELETE,

} process_command_t;

class CMyProcess  : public CMyThread
{
public:
 CMyProcess();
 virtual ~CMyProcess();

private:
 LPVOID   m_lpUser;
 ProcessCallback m_pCallback;

public:
 void SetCallback(LPVOID lpUser, ProcessCallback callback);

 virtual void DeleteData(void *pData);
 
 BOOL Init();
 BOOL ReInit();
 BOOL UnInit();
 
private:
 BOOL Work();
 BOOL BeforeWork();
 BOOL AfterWork(); 
 BOOL Process(void *pData);
};

#endif // !defined(AFX_MYPROCESS_H__F958678E_5978_421D_BE7E_56D6266DE6FB__INCLUDED_)
// MyProcess.cpp: implementation of the CMyProcess class.
//
//

#include "stdafx.h"
#include "MyProcess.h"

//
// Construction/Destruction
//

CMyProcess::CMyProcess()
{
 this->m_lpUser  = NULL;
 this->m_pCallback = NULL;
}

CMyProcess::~CMyProcess()
{
 this->UnInit();
}

void CMyProcess::SetCallback(LPVOID lpUser, ProcessCallback callback)
{
 this->m_lpUser  = lpUser;
 this->m_pCallback = callback; 
}

void CMyProcess::DeleteData(void *pData)
{
 this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_DELETE, pData);
}

BOOL CMyProcess::Work(void)
{
 return this->Process(NULL);
}

BOOL CMyProcess::BeforeWork()
{
 return this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_BEFORE, NULL);
}

BOOL CMyProcess::AfterWork()
{
 return this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_AFTER, NULL);
}

BOOL CMyProcess::Init()
{
 return TRUE;
}

BOOL CMyProcess::ReInit()
{
 return TRUE;
}

BOOL CMyProcess::UnInit()
{
 return TRUE;
}

BOOL CMyProcess::Process(void* pData)
{
 return this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_PROCESS, pData);
}
/************************************************************************

  * 版权所有 (C)2008, 陈彦旭。
  *
  * 文件名称： MyMutex.h
  * 内容摘要： 互斥资源管理和使用
  * 其它说明：
  * 当前版本： 1.0.0.0
  * 作    者： 陈彦旭
  * 完成日期： 2008年01月20日
 
************************************************************************/

#if !defined(AFX_MYMUTEX_H__A0C8824F_B61A_443B_83DA_7F73FC0FD481__INCLUDED_)
#define AFX_MYMUTEX_H__A0C8824F_B61A_443B_83DA_7F73FC0FD481__INCLUDED_

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

class CMyMutex 
{
public:
 CMyMutex();
 virtual ~CMyMutex();
public:
 BOOL Lock(DWORD dwLockTime=INFINITE);
 void Unlock();
 BOOL TryLock();

private:
 CRITICAL_SECTION m_Mutex;

};

class CUseMutex
{
public:
 CUseMutex();
 CUseMutex(CMyMutex* plock, BOOL bLock=TRUE, DWORD dwLockTime=INFINITE);
 virtual ~CUseMutex();
 
public: 
 BOOL IsUseLock();
 BOOL UseLock(DWORD dwLockTime=INFINITE);
 BOOL UseLock(CMyMutex* plock, BOOL bLock, DWORD dwLockTime=INFINITE);
 void UseUnlock();
 
private:
 BOOL m_bLock;
 CMyMutex* m_pLock;
};

#endif // !defined(AFX_MYMUTEX_H__A0C8824F_B61A_443B_83DA_7F73FC0FD481__INCLUDED_)

// MyMutex.cpp: implementation of the CMyMutex class.
//
//

#include "stdafx.h"
#include "MyMutex.h"

//
// Construction/Destruction
//

CMyMutex::CMyMutex()
{
 ::InitializeCriticalSection(&this->m_Mutex);
}

CMyMutex::~CMyMutex()
{
 ::DeleteCriticalSection(&this->m_Mutex);
}

BOOL CMyMutex::Lock(DWORD dwLockTime)
{
 ::EnterCriticalSection(&this->m_Mutex);
 return TRUE;
}

void CMyMutex::Unlock()
{
 ::LeaveCriticalSection(&this->m_Mutex);
}

BOOL CMyMutex::TryLock()
{
#if(_WIN32_WINNT >= 0x0400)
 ::TryEnterCriticalSection(&this->m_Mutex);
#else
 ::EnterCriticalSection(&this->m_Mutex);
#endif
 return FALSE;
}

CUseMutex::CUseMutex()
{
 this->m_pLock = NULL;
 this->m_bLock = FALSE;
}

CUseMutex::CUseMutex(CMyMutex* plock, BOOL bLock, DWORD dwLockTime)
{
 this->m_pLock = plock;
 this->m_bLock = FALSE;
 
 if (this->m_pLock && bLock)
 {
  this->m_bLock = this->m_pLock->Lock(dwLockTime);
 }
}

CUseMutex::~CUseMutex()
{
 this->UseUnlock();
}
 
BOOL CUseMutex::IsUseLock()
{
 return (this->m_pLock && this->m_bLock);
}

BOOL CUseMutex::UseLock(DWORD dwLockTime)
{
 if (this->m_pLock && !this->m_bLock)
  this->m_bLock = this->m_pLock->Lock(dwLockTime);

 return this->m_bLock;
}

BOOL CUseMutex::UseLock(CMyMutex* plock, BOOL bLock, DWORD dwLockTime)
{ 
 this->UseUnlock();

 this->m_pLock = plock;
 this->m_bLock = FALSE;

 if (this->m_pLock && bLock)
  return this->m_bLock = this->m_pLock->Lock(dwLockTime);

 return FALSE;
}

void CUseMutex::UseUnlock()
{
 if (this->IsUseLock())
  this->m_pLock->Unlock();

 this->m_bLock = FALSE;
}

我是安全搬运工
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统：11 线程管理
snowysc的博客
05-11 683
线程管理
线程管理工具类
05-15
使用示例`ThreadManager.getDefault().execute()`表明，该工具类提供了一个默认的线程管理器实例，并且有一个简单的`execute()`方法来执行任务。这可能意味着这个工具类内部维护了一个线程池，`execute()`方法将提交...
Windows多线程管理
stephen0208的博客
12-01 658
信号量 CreateSemaphore——创建信号量 createsemaphore函数创建一个已命名或未命名的信号量对象 HANDLE CreateSemaphore( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCTSTR lpName ); 1. 参数 lpSemaphoreAttributes:[IN] 设置为NULL; lInitialCoun
windows 进程与线程讲解（1）
ylh的博客
10-12 991
什么是windows内核对象？ 内核对象的创建及操作，进程线程与模块的遍历操作
操作系统的线程管理
n_229397218的博客
03-06 986
线程发生 I/O 或页面故障引起的阻塞时，如果调用阻塞系统调用，则内核由于不知道有线程的存在，而会阻塞整个进程从而阻塞所有线程直到磁盘 I/O 完成为止（尽管其他线程是可以运行的），因此同一进程中只能同时有一个线程在运行；也就是说，核外的用户空间的线程通过一个机制和核内的一个内核级线程对应起来，那么调度内核的这个线程上CPU也就是调度核外的线程上的CPU。线程切换速度非常快，创建和销毁线程、线程切换代价等线程管理的代价比内核线程少得多，因为保存线程状态的过程和调用程序都只是本地过程；
C++11 在 Windows 环境下的多线程编程指南
最新发布
威桑的博客
05-31 781
C++11Windows多线程开发
一种简单的Linux线程管理接口
04-05
C语言程序代码，线程管理函数接口，实现线程的创建和管理，使用于多线程业务的线程管理。用于线程管理接口开发提供参考。
TaskManager2.zip 简单winform 多线程 多任务管理 demo
02-14
《基于C# .NET的简单Winform多线程多任务管理Demo详解》 在软件开发中，尤其是在Windows桌面应用领域，有效地管理和调度多线程、多任务是提升程序性能和用户体验的关键。本篇将深入探讨“TaskManager2.zip”这个...
OC多线程管理
11-10
在iOS和OS X开发中，Objective-C（OC）的多线程管理是至关重要的技能，它关乎应用的性能、响应速度以及资源利用效率。多线程允许程序同时执行多个任务，提升用户体验，尤其是在处理耗时操作如网络请求、大数据计算或...
Qt 多线程简单实例
10-30
在给定的"Qt多线程简单实例"中，我们关注的核心是如何创建和管理线程，以及如何通过用户交互来控制线程的执行。 首先，Qt中的多线程主要依赖于`QThread`类。`QThread`为用户提供了一个在新线程中执行对象的方法，...
易语言简单线程读网页
07-19
本源码示例——"易语言简单线程读网页"，就是利用易语言实现了一个线程来读取网页内容，从而避免了主线程阻塞，提高了程序的响应性。 首先，我们需要理解易语言中的线程是如何工作的。易语言提供了"创建线程"、...
qt多线程简单
01-04
Qt 5.6及以上版本引入了QThreadPool类，它提供了一个线程池机制，可以更高效地管理和复用线程。通过将任务添加到线程池，系统会自动分配合适的线程来执行这些任务。 总结，Qt的多线程功能使得开发者能够轻松地在C++...
C++简单多线程
02-27
在C++ Builder中，我们可以使用`System::Classes::TThread`类来创建和管理线程。首先，我们需要定义一个继承自`TThread`的类，覆盖`Execute`方法，这是线程执行的主要逻辑。例如，你可以在这个方法中实现数据处理...
QT 简单实现多线程
11-25
标签“QT线程”进一步强调了讨论的重点是QT库中的线程管理。在实际开发中，理解QThread的生命周期、线程同步机制（如QMutex、QSemaphore等）、以及如何避免数据竞争和死锁等问题，都是至关重要的。 文件名“QThread...
简单的线程
12-20
在JNP2014这个压缩包文件中，可能包含了一个简单的Java线程示例代码，用于教学或演示如何在Java中创建和管理线程。通过查看和分析这些代码，开发者可以更好地理解线程的工作原理以及如何在实际项目中应用。
网络编程（42）—— windows平台下创建线程的四种方法（一）
Hyman的博客
12-21 1837
一、引言        接下来，笔者主要谈下Windows平台下多线程的用法。首先，要强调一点，Windows平台的线程linux中的线程不同，它会伴着主函数的结束而销毁。Windows平台下可用的创建多线程的API共有四个，分别是： (1) CreateThread()         CreateThread是Windows的API函数，提供操作系统级别的创建线程的操作，且仅限于工作者线
二、进程管理（一）进程与线程
24考研人晴落的博客
11-23 1099
在多道程序环境下，允许多个程序并发执行。传统的程序本身是一组指令的集合，是一个静态的概念。引入进程（Process）的概念来描述多个程序并发执行的动态过程。
多线程学习------06线程管理
Striving
07-26 479
线程管理
【玩转RT-Thread】线程管理（详细原理）
以放的博客
04-13 6115
文章目录一、序言二、线程管理的功能特点 一、序言 在日常生活中，我们通常会将一个大的问题拆分细化，拆开成若干个小问题，通过逐个解决小问题，大问题也就解决了。 同样的在RT-Thread多线程操作系统中，开发人员基于这种分而治之的思想，将一个复杂的应用问题抽象成若干个小的、可调度的、可序列化的程序单元。当合理地划分任务并正确地执行时，这种设计能够让系统满足实时系统的性能及时间的要求。 下面看一个例子：我们的任务是读取传感器上的数据，并将相关数据显示出来。通过拆分结构，我们可以发现主要有两个任务： 1.读取数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值