线程池管理

最新推荐文章于 2021-03-01 21:37:38 发布
转载 最新推荐文章于 2021-03-01 21:37:38 发布 · 685 阅读 · 0
文章标签：

#null #winapi #delete #任务 #class #thread

本文介绍了一个线程池管理系统的设计与实现，包括线程管理和任务调度等核心功能。系统支持线程的启动、终止及任务的添加与执行。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

// 申明
class CManageThread  
{
public:
CManageThread();
virtual ~CManageThread();
private:
HANDLE m_HThread;//线程句柄
HANDLE m_HEvent;//结束空闲线程通知
IThreadExcute* m_te;
CSemaphore *m_section;
public:
    bool ExcuteThread();
//-----------------------------------
bool PostExitThread();
bool TerminateExitThread();
//-----------------------------------
HANDLE GetThreadEvent();//获取通知句柄
HANDLE GetThreadHandle();//获取线程句柄
bool GetThreadIsLeisure();
    void SetThreadExcute(IThreadExcute *pte);
void SetThreadHandle(HANDLE handle);
//---------------------------------------------
//锁定当前线程
bool SetLockThread(int tm=0);
};

class CTemporarilyThread  
{
public:
CTemporarilyThread();
virtual ~CTemporarilyThread();
private:
    HANDLE m_HThread;
    IThreadExcute* m_te;
public:
bool TerminateExitThread();
bool ExcuteThread();
HANDLE GetThreadHandle();//获取线程句柄
    void SetThreadExcute(IThreadExcute *pte);
void SetThreadHandle(HANDLE handle);
};

class CThreadPoolManage  
{
private:
CThreadPoolManage();
virtual ~CThreadPoolManage();
private:
    static CThreadPoolManage* m_ChreadPoolManage;
static CArray<CTemporarilyThread*,CTemporarilyThread*> m_ATemporarily;
static CArray<CManageThread*,CManageThread*> m_AManageThread;
    static CSemaphore m_sem;
    static CCriticalSection section;
public:
    static CThreadPoolManage* GetThreadPoolManage();
static void CloseThreadPoolManage();
private:
//装载临时任务
static DWORD WINAPI ExcuteMission(LPVOID n);
    //装载空闲任务
static DWORD WINAPI ExcuteLeisureMission(LPVOID n);
private:
  
public:
    bool AddMission(IThreadExcute* pte);//添加任务
bool SatartTemporarilyThread(int count);//启动一到多个空闲线程
int CloseTemporarilyThread(int count);//关闭一到多个空闲线程
bool CloseTemporarilyThreadAll();//关闭所有空闲线程
int GetThreadPoolCount();//获取当前远行的线程数量    
};

class IThreadExcute  
{
public:
IThreadExcute();
virtual ~IThreadExcute();
public:
    virtual void ExcuteThread();
};

// 实现
CManageThread::CManageThread()
{
    m_HThread = NULL;
m_te = NULL;
m_HEvent = NULL;
m_section = new CSemaphore(1,1);
m_section->Unlock();
}
CManageThread::~CManageThread()
{
   delete m_section;
   CloseHandle(m_HEvent);
}
bool CManageThread::ExcuteThread()
{
   try
   {
      while(1)
   {
   if(WaitForSingleObject(m_HEvent,0)!=WAIT_TIMEOUT)
   {
   ResetEvent(m_HEvent);
            break;
   }
   try
   {
      if(m_te!=NULL)
         m_te->ExcuteThread();
   m_section->Unlock();
   }
         catch(...)
   {
      m_te = NULL;
   m_section->Unlock();
   }
   m_te = NULL;
   }    
   }
   catch(...)
   {
  ResetEvent(m_HEvent);
  m_section->Unlock();
  m_te = NULL;
     return false;
   }
   m_section->Unlock();
   m_te = NULL;
   return true;
}
bool CManageThread::PostExitThread()
{
try
{
  if(m_HEvent!=NULL)
     SetEvent(m_HEvent);
}
catch(...)
{
  return false;
}
return true;
}
bool CManageThread::TerminateExitThread()
{
   try  
   {
    if(m_HThread!=NULL)
     TerminateThread(m_HThread,0);
    m_section->Unlock();
   }
   catch(...)
   {
       m_section->Unlock();
    return false;
   }
   return true;
}
HANDLE CManageThread::GetThreadEvent()
{
return m_HEvent;
}
void CManageThread::SetThreadExcute(IThreadExcute *pte)
{
    m_te = pte;
}
HANDLE CManageThread::GetThreadHandle()//获取线程句柄
{
return m_HThread;
}
bool CManageThread::GetThreadIsLeisure()
{
return (m_te==NULL)?true:false;
}
void CManageThread::SetThreadHandle(HANDLE handle)
{
    m_HThread = handle;
CString EventStr;
EventStr.Format("%d",m_HThread);
m_HEvent = CreateEvent(NULL,true,false,EventStr);
ResetEvent(m_HEvent);
}
//锁定当前线程
bool CManageThread::SetLockThread(int tm)
{
return (m_section->Lock(tm)==0)?false:true;
}

CTemporarilyThread::CTemporarilyThread()
{
    m_HThread = NULL;
m_te = NULL;
}
CTemporarilyThread::~CTemporarilyThread()
{
}
bool CTemporarilyThread::TerminateExitThread()
{
   try
   {
      if(m_HThread!=NULL)
    TerminateThread(m_HThread,0);
   }
   catch(...)
   {
    return false;
   }
   return true;
}
bool CTemporarilyThread::ExcuteThread()
{
    try
{
  if(m_te!=NULL)
   m_te->ExcuteThread();
}
catch(...)
{
  return false;
}
return true;
}
HANDLE CTemporarilyThread::GetThreadHandle()//获取线程句柄
{
   return m_HThread;
}
void CTemporarilyThread::SetThreadExcute(IThreadExcute *pte)
{
   m_te = pte;
}
void CTemporarilyThread::SetThreadHandle(HANDLE handle)
{
m_HThread = handle;
}

CThreadPoolManage::CThreadPoolManage()
{
}  
CThreadPoolManage::~CThreadPoolManage()
{
}
CThreadPoolManage* CThreadPoolManage::m_ChreadPoolManage = NULL;
CArray<CManageThread*,CManageThread*> CThreadPoolManage::m_AManageThread;
CArray<CTemporarilyThread*,CTemporarilyThread*> CThreadPoolManage::m_ATemporarily;
//初始化信号量
CSemaphore CThreadPoolManage::m_sem(MAX_THREAD,MAX_THREAD);
CCriticalSection CThreadPoolManage::section;
CThreadPoolManage* CThreadPoolManage::GetThreadPoolManage()
{
   if(m_ChreadPoolManage==NULL)
   {
    m_ChreadPoolManage = new CThreadPoolManage();
    m_AManageThread.RemoveAll();
       m_ATemporarily.RemoveAll();
   }
   return m_ChreadPoolManage;
}
void CThreadPoolManage::CloseThreadPoolManage()
{
   delete m_ChreadPoolManage;
   m_ChreadPoolManage = NULL;
}
DWORD WINAPI CThreadPoolManage::ExcuteMission(LPVOID n)
{
CTemporarilyThread* pte = (CTemporarilyThread*)n;
CTemporarilyThread* ptef = NULL;
    int i = 0;
if(pte!=NULL)
{
  try
  {
         pte->ExcuteThread();
  }
  catch(...)
  {
  }
}
    if(pte!=NULL)
{
  try
  {
   while(section.Lock(10000)==0);
   for(i=0;i<m_ATemporarily.GetSize();i++)
   {
                ptef = m_ATemporarily.GetAt(i);
    if(pte->GetThreadHandle()==ptef->GetThreadHandle())
    {
                    m_ATemporarily.RemoveAt(i);
     delete ptef;
     break;
    }
   }
   section.Unlock();
  }
  catch(...)
  {
            section.Unlock();
  }
}
    m_sem.Unlock();
    pte = NULL;
ptef = NULL;
return 0;
}
//装载空闲任务
DWORD WINAPI CThreadPoolManage::ExcuteLeisureMission(LPVOID n)
{
   CRegKeyIni ini;
   int i = 0;
   CManageThread* pmt = NULL;
   CManageThread* pManageThread = (CManageThread*)n;
   if(pManageThread!=NULL)
   {
    try
    {
    pManageThread->ExcuteThread();
    }
    catch(...)
    {
    }
   }
//----------删除除在队列中的记录---------------------
   if(pManageThread != NULL)
   {
    while(section.Lock(10000)==0);
CString str2,str1;
CTime tm = CTime::GetCurrentTime();
str2.Format("%d:%d:%d",tm.GetHour(),tm.GetMinute(),tm.GetSecond());
str1.Format("%d===hhhhhhhhhhh",pManageThread->GetThreadEvent());
ini.WriteIniStringAndCurrentDir(str1,str2,"123456","wangwei.ini");
    try
    {
     for(i=0;i<m_AManageThread.GetSize();i++)
     {
      pmt = m_AManageThread.GetAt(i);
      if(pmt!=NULL)      
        if(pmt->GetThreadHandle()==pManageThread->GetThreadHandle())
     {
                    m_AManageThread.RemoveAt(i);
     CString str,str1;
     CTime tm = CTime::GetCurrentTime();
     str1.Format("%d:%d:%d",tm.GetHour(),tm.GetMinute(),tm.GetSecond());
     str.Format("%d",pmt->GetThreadEvent());
     ini.WriteIniStringAndCurrentDir(str,str1,"ww","tt.ini");
                    delete pmt;    
     break;
     }      
     }
           section.Unlock();
    }
    catch(...)
    {
           section.Unlock();
    }
   }
   m_sem.Unlock();
   pmt = NULL;
   pManageThread = NULL;
//---------------------------------------------------
   return 0;
}
bool CThreadPoolManage::AddMission(IThreadExcute* pte)
{
CTemporarilyThread* ptt = NULL;
CManageThread* pmt = NULL;
    int i = 0;
DWORD id = 0;
HANDLE handle = NULL;
if(m_sem.Lock()==0)//任务已满
  return false;
try
{
//-----------查询是否存在空闲线程------------------
  if(section.Lock(10000)!=0)
  {
   for(i=0;i<m_AManageThread.GetSize();i++)
   {
               pmt = (CManageThread*)m_AManageThread.GetAt(i);            
      if(pmt->SetLockThread())
      {
                  pmt->SetThreadExcute(pte);
      break;
      }
   }
   if(i==m_AManageThread.GetSize())//不存在已经启动空闲线程
   {
                ptt = new CTemporarilyThread();
    handle = CreateThread(NULL,NULL,ExcuteMission,(LPVOID)ptt,CREATE_SUSPENDED,&id);
    ptt->SetThreadHandle(handle);
    ptt->SetThreadExcute(pte);
       m_ATemporarily.Add(ptt);
                ResumeThread(handle);
   }
   section.Unlock();
  }
  else return false;
//-------------------------------------------------
}
catch(...)
{
  section.Unlock();
  return false;
}
return true;
}
bool CThreadPoolManage::SatartTemporarilyThread(int count)//启动一到多个空闲线程
{
   int i = 0;
   CManageThread* pmt = NULL;
   HANDLE handle = NULL;
   DWORD id = 0;
   if(count>(MAX_LEISURE-m_AManageThread.GetSize()))
    return false;
   for(i=0;i<count;i++)
   {
      pmt = new CManageThread();
      handle = CreateThread(NULL,NULL,ExcuteLeisureMission,(LPVOID)pmt,CREATE_SUSPENDED,&id);
   pmt->SetThreadHandle(handle);
   m_AManageThread.Add(pmt);
   ResumeThread(handle);  
   }
   return true;
}
//关闭一到多个空闲线程,返回实际关闭的空闲线程数量
int CThreadPoolManage::CloseTemporarilyThread(int count)
{
   int i = 0;
   int js = 0;
   CManageThread* pmt = NULL;
   if(count > m_AManageThread.GetSize())
    return -1;
   if(section.Lock(10000)!=0)
   {
    try
    {
     for(i=(count-1);i>=0;i--)
     {
     pmt = m_AManageThread.GetAt(i);
     if(pmt->SetLockThread())
     {
     if(pmt->PostExitThread())
     {
      if(!pmt->SetLockThread(1000))
      {
       pmt->TerminateExitThread();
       m_AManageThread.RemoveAt(i);
       delete pmt;
      }
     }
     js++;
     }
     }
          section.Unlock();
    }
    catch(...)
    {
          section.Unlock();
    }
   }
   return js;
}
bool CThreadPoolManage::CloseTemporarilyThreadAll()//关闭所有线程池线程
{
   CRegKeyIni ini;
   CTemporarilyThread* ptt = NULL;
   CManageThread* pmt = NULL;
   int i = 0;
   int count = 0;
   int js = 0;
   while(section.Lock(10000)==0);
CString str2;
CTime tm = CTime::GetCurrentTime();
str2.Format("%d:%d:%d",tm.GetHour(),tm.GetMinute(),tm.GetSecond());
ini.WriteIniStringAndCurrentDir("HHHHHHHHH",str2,"123456","wangwei.ini");
   try
   {
       count = m_AManageThread.GetSize();
    for(i=(count-1);i>=0;i--)
    {
           pmt = m_AManageThread.GetAt(i);
           if(pmt->PostExitThread())
     {
      if(!pmt->SetLockThread(1000))
      {
                   pmt->TerminateExitThread();
       m_AManageThread.RemoveAt(i);
     CString str,str1;
     CTime tm = CTime::GetCurrentTime();
     str1.Format("%d:%d:%d",tm.GetHour(),tm.GetMinute(),tm.GetSecond());
     str.Format("%d",pmt->GetThreadEvent());
     ini.WriteIniStringAndCurrentDir(str,str1,"123456","tt.ini");
       delete pmt;      
      }
      js++;
     }
    }
   CString str;
   str.Format("%d",js);
   ::AfxMessageBox(str);
       count = m_ATemporarily.GetSize();
    for(i=(count-1);i>=0;i--)
    {
           ptt = m_ATemporarily.GetAt(i);
     ptt->TerminateExitThread();
     m_ATemporarily.RemoveAt(i);
     delete ptt;
    }
    section.Unlock();
   }
   catch(...)
   {
    section.Unlock();
    return false;
   }
   return true;
}
int CThreadPoolManage::GetThreadPoolCount()//获取当前远行的线程数量
{
   return m_AManageThread.GetSize()+m_ATemporarily.GetSize();
}

注:CManageThread负责管理单个线程，CThreadPoolManage负责管理线程池，单例实现

C++线程池管理
程序猿老樊的博客
08-31 722
管理C++线程池涉及创建、调度和终止线程的机制，以有效地处理并发任务。以下是一个基本的线程池管理示例，包括线程池的创建、任务分配和线程池的销毁。
ExecutorService详解：Java 17线程池管理从零到一
最新发布
全栈
05-15 1206
本文深度解析Java 17中ExecutorService线程池管理技术，涵盖线程池核心概念、参数配置、拒绝策略、动态调整及企业级实战案例。通过代码示例详解FixedThreadPool、CachedThreadPool等类型选择，结合监控指标与调优策略，帮助开发者构建高性能、可扩展的并发架构，解决资源竞争与系统过载问题。
C#管理线程池的类ThreadManager
04-18
C#管理线程池的类 /* How to use Thread Classs * * ============== * public ELMService() { InitializeComponent(); etm.ClalThreadPool("EmailThreads", (uint)ApplicationInfo.EmailParsingThreads); } * //queue items in thread for processing. * etm.QueueUserEmailWorkItem(new WaitCallback(ELMService_UpdateLogHandler), objSupplier); public void ELMService_UpdateLogHandler(object objmsg) * { * return; * } * */
threadmanage
zhihu008的专栏
09-21 1309
////threadmanage.h #pragma once #ifndef THREADMANAGE_H #define THREADMANAGE_H //#include "SAStatusLog.h" #include "DealData.h" #include "ErgodicFile.h" #include #include #include #inclu
线程管理（Thread Management）
小言的专栏
01-29 3999
OS X或iOS每个进程（应用）是由一个或多个线程组成，每个线程代表通过应用代码执行的一个路径。每个应用从一个线程开始，用来运行应用的main函数。应用可以产生额外的线程，每个线程执行特定功能的代码。 当应用生成一个新线程时，该线程成为应用进程空间内的独立实体。每个线程都有自己的执行堆栈并且由内核独立安排运行时。一个线程可以与其他线程和其他进程通信，执行 I/O 操作，和其他任何你需要做的。
Mysql源码学习——Thread Manager
sweetfire的博客
07-27 265
一、前言     上篇的Connection Manager中，曾提及对于一个新到来的Connection，服务器会创建一个新的线程来处理这个连接。 其实没那么简单，为了提高系统效率，减少频繁创建线程和中止线程的系统消耗，Mysql使用了线程缓冲区的概念，即如果 一个连接断开，则并不销毁承载其的线程，而是将此线程放入线程缓冲区，并处于挂起状态，当下一个新的Connection到来   &...
以前写的一个线程管理器--ThreadManager
摇滚程序员
03-26 288
windows下适当的使用多线程能增加程序运行效率，不过winapi自带的线程接口函数直接调用多了可能会有点乱，所以我对其进行了2次封装，增加了oo特性。 编译后生成ThreadManager.lib,ThreadManager.dll以供调用。 ThreadManager.h [code="c++"] #pragma once #include #include #in...
JAVA线程池管理及分布式HADOOP调度框架搭建
12-22
平时的开发中线程是个少不了的东西，比如tomcat里的servlet是线程，没有线程我们如何提供多用户访问呢？不过很多刚开始接触线程的开发攻城师却在这个上面吃了不少苦头。怎么做一套简便的线程开发模式框架让大家从单...
(源码)基于C++的线程池管理系统.zip
11-13
# 基于C++的线程池管理系统 ## 项目简介 本项目是一个基于C++实现的线程池管理系统，旨在提供高效、灵活的多线程任务管理功能。通过多种工作模式和任务优先级管理，项目能够适应不同的任务负载需求，并确保任务的...
实现了ThreadManager类，在程序中自动管理线程(15kb)
02-23
实现了ThreadManager类，在程序中自动管理线程(15kb)
Java Task-Thread Manager-开源
04-26
线程和任务管理器。 在线程池中执行任务。
第一章 Thread Management(线程管理) 下
往前的娘娘
08-11 415
涉及内容 创建和运行一个线程获取和设置线程信息打断一个线程控制打断的线程休眠和唤醒线程等待线程的终止创建和运行守护线程处理线程中不受控制的异常使用local thread变量将线程加入组处理线程组的不受控制的异常通过工厂创建线程 1、使用local thread变量 线程之间共享变量或者不共享变量 例子：local thread 变量机制 外部变量 package com.
ThreadManager分析
奔向火星的博客
05-22 3452
类图如下： ThreadManager是采用单例模式创建的：ThreadManager* ThreadManager::Instance() { RTC_DEFINE_STATIC_LOCAL(ThreadManager, thread_manager, ()); return &thread_manager; }#define RTC_DEFINE_STATIC_LOCAL(type,
线程池原理及创建
11-14 1009
线程池原理及创建本文给出了一个通用的线程池框架，该框架将与线程执行相关的任务进行了高层次的抽象，使之与具体的执行任务无关。另外该线程池具有动态伸缩性，它能根据执行任务的轻重自动调整线程池中线程的数量。文章的最后，我们给出一个简单示例程序，通过该示例程序，我们会发现，通过该线程池框架执行多线程任务是多么的简单。为什么需要线程池目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器
别new Thread()，简单实现线程管理ThreadManager
weixin_34138521的博客
04-05 548
直接开车......复制代码直接上代码，ThreadManager类：public class ThreadManager { //获取内核数量 private final static int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors(); private final static T...
java threadpoolmanager_理解Java线程池ThreadPoolExecutor
weixin_39640395的博客
03-01 492
在Java的线程池的使用会有比较多的地方，有比较多的应用场景，介绍一下Java线程池ThreadPoolExecutor。线程是一个操作系统概念。操作系统负责这个线程的创建、挂起、运行、阻塞和终结操作。而操作系统创建线程、切换线程状态、终结线程都要进行CPU调度----这是一个耗费时间和系统资源的事情。大多数实际场景中是这样的：处理某一次请求的时间是非常短暂的，但是请求数量是巨大的。这种背景下，如...
Tool.Net 开源-ManagedThreadPool类
逆-血
12-15 275
移除Tool.Utils.ManagedThreadPool类 移除原因：因为.net5中已经将Thread类中很多线程操作函数，声明为已过时，导致用户无法正常使用该类，现将该类公开。 源码公开如下： using System; using System.Collections; using System.Collections.Generic; using System.Text; using System.Threading; namespace Tool.Utils { /// <
线程池
lusic01的专栏
03-06 334
简单的搭建一个高并发低时延系统首先声明一点：这里的“高并发”是相对的，相对于硬件而言，而不是绝对的高并发。后者需要分布式来实现，这里不做讨论。本文关注的是单机的高并发。最近在做一个语音通信系统，要求在线用户2W，并发1K路通话。硬件是两台服务器，酷睿多核，4G内存，千兆网卡（我用过的最好的硬件，负担这些应该问题不大）。系统的另一个指标是呼叫时延和语音时延。这是这个系统的关键。最终我们的系统拿到用户...
深入解析Java线程池管理源码机制
由于提供的信息非常有限，并没有给出具体的源码内容或详细描述，我将基于常见的Java线程池管理源码知识点进行说明。 线程池是Java并发编程中的一个重要概念，它可以有效地管理线程的生命周期，优化资源利用，减少...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值