按"利用C++语言设计可扩展线程池"文章实现代码,但是有问题,希望大家来讨论,指出问题,谢谢

最新推荐文章于 2024-05-01 19:10:24 发布
最新推荐文章于 2024-05-01 19:10:24 发布
阅读量2.2k 收藏 5
点赞数
分类专栏： c/c++ 文章标签： 扩展 语言 c++ 任务 iterator null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tdjdyq/article/details/3964695
版权

http://blog.csdn.net/tdjdyq/archive/2009/03/06/3964681.aspx

 

利用C++语言设计可扩展线程池

 

/

 

core_threadpool.h

//

 

#ifndef _CORE_THREADPOOL_H_
#define _CORE_THREADPOOL_H_


#include "icl_classes.h"
#include "icl_thread.h"

#include "core_base.h"

#include<deque>


using namespace icl;

#define TIMESJW 60000

class CThreadPool : public CThread
{
friend class CWorkThread;
public:
    CThreadPool( int _size, int nMaxSize);
 ~CThreadPool(void);
 void AddTask(CBase *pBase);
 unsigned int GetThreadCount(void);
 int GetTaskCount();
 void OnTaskIdle(CWorkThread *pThread);
    bool PoolFree();
    void Stop();
private:
    void Destroy(void);
    void DestroyAllThread(void);
    void JoinWithAllThreads(void);
 void Execute(void);
 void GetTask(list<CBase*> &pBaseList,int nSize = 1);
    void SetTask(list<CBase*> pTaskList);
 bool TaskIsEmpty(void);
    CWorkThread* GetIdleThread();
 bool CheckNewTask();
    void CreateNewThread();// 创建新线程
    bool WaitForTaskOrThreadTimeout();
    long IncrIdleTime();
    void DecrIdleThread();
    bool SetThreadTask(list<CBase*> pTaskList);
 void AddTaskToThread(list<CBase*> pTaskList,CWorkThread *pThread);
    int SjwSuspendThread(CWorkThread * pThread);
    int SjwResumeThread(CWorkThread * pThread);
 void UpdateThread();
private:
 const int m_nSize;
    const int m_nMaxSize;
    unsigned int m_nThread;
 unsigned int m_nCount;

    unsigned long m_nLastTime;
    long m_nTime;
 bool m_bStoped;
    bool m_bWorkThreaFree;
 list<CBase*> m_TaskList;
    CCriticalSection m_TaskLock;
    CList m_ThreadList;
    CCriticalSection m_ThreadLock;
    CList m_RunThreadList;
    CCriticalSection m_RunThreadLock;
private:
 CThreadPool(const CThreadPool&);
 CThreadPool& operator=(const CThreadPool&);
};

class CWorkThread : public CThread
{
public:
    CWorkThread(const CThreadPool*);
    ~CWorkThread();
    virtual void Execute(void);
    bool CheckTaskQueue();
    bool WaitForTask();
 CBase* GetTask();
    void SetTaskList(list<CBase*> pTaskList);
    void SetThreadExit(bool bExit){ m_bThreadExit = bExit; }
    bool GetThreadExit(){ return m_bThreadExit; }
    bool GetThreadExitFlag(){ return m_bThreadExitFlag;}
    void SetThreadState(int bFree){ m_nThreadState = bFree; }
    int GetThreadState(){ return m_nThreadState; }
private:
    CThreadPool *m_pool;
 CBase *m_pBaseTask;
    CCriticalSection m_Lock;
 deque<CBase*> m_Queue;
    bool m_bThreadExit;
    bool m_bThreadExitFlag;
    int m_nThreadState; //0，运行；1，没有任务的空闲；2，挂起
};

#endif

 

core_threadpool.cpp

//

 

#include "core_threadpool.h"
#include "icl_socket.h"
#include "icl_sysutils.h"


CThreadPool::CThreadPool( int _size, int nMaxSize):m_nSize(_size),m_nMaxSize(nMaxSize),m_bWorkThreaFree(false),m_nTime(0)
{
    m_nTime = TIMESJW;
    m_nCount = 0;
 m_bStoped = true;
 if(m_nSize < 1)
 {
  const_cast< int &>(m_nSize) = 1;
 }
 for( int i=0; i< m_nSize; i++)
 {
        CWorkThread *hThread = new CWorkThread(this);
  m_ThreadList.Add(hThread);
  hThread->Run();
 }
 m_nCount = m_nSize;
    m_nLastTime = 0;
 m_bStoped = false;
}

CThreadPool::~CThreadPool(void)
{
 Stop();
}

void CThreadPool::Stop()
{
 if(! m_bStoped)
 {
  Destroy();
        DestroyAllThread();
        m_bStoped = true;
 }
}

void CThreadPool::Destroy(void)
{
    CAutoSynchronizer Syncher(m_TaskLock);
 list<CBase*>::iterator it ;
 for(it = m_TaskList.begin(); it != m_TaskList.end(); ++it)
 {
        delete (*it);
 }
    m_TaskList.clear();
}

void CThreadPool::DestroyAllThread(void)
{
    const int MAX_THREAD_WAIT_FOR_SECS = 10; // 线程池清空时最多等待时间(秒)
    const double SLEEP_INTERVAL = 0.5;      // 每次等待的时间间隔(秒)
    double nWaitSecs = 0;

    // 通知线程退出
    {
        CAutoSynchronizer Syncher(m_ThreadLock);
        for (int i = 0; i < m_ThreadList.Count(); i++)
        {
            CWorkThread *pThread;
            pThread = (CWorkThread*)m_ThreadList[i];
            pThread->Terminate();
        }
    }

    // 等待线程退出
    while (nWaitSecs < MAX_THREAD_WAIT_FOR_SECS)
    {
        if (m_ThreadList.Count() == 0) break;
        NanoSleep(SLEEP_INTERVAL, true);
        nWaitSecs += SLEEP_INTERVAL;
    }

    printf("若等待超时，则强行杀死各线程/n");

    // 若等待超时，则强行杀死各线程
    if (m_ThreadList.Count() > 0)
    {
        CAutoSynchronizer Syncher(m_ThreadLock);
        for (int i = 0; i < m_ThreadList.Count(); i++)
        {
            CWorkThread *pThread;
            pThread = (CWorkThread*)m_ThreadList[i];
            pThread->Kill();
        }
        m_ThreadList.Clear();
    }
}

bool CThreadPool::TaskIsEmpty()
{
 CAutoSynchronizer Syncher(m_TaskLock);
    bool bFlag =  m_TaskList.empty();
 return bFlag;

}

void CThreadPool::OnTaskIdle(CWorkThread *pThread)
{
    pThread->SetThreadState(1);
}


void CThreadPool::GetTask(list<CBase*> &pTaskList,int nSize)
{
 {
  CAutoSynchronizer Syncher(m_TaskLock);
  int nIndex = 0;
  while(nIndex<nSize)
  {
         CBase *pBaseTask = NULL;
   pBaseTask = m_TaskList.front();
   if(pBaseTask)
   {
    pTaskList.push_back(pBaseTask);
    m_TaskList.pop_front();
   }
   nIndex++;
  }
 }
}

void CThreadPool::SetTask(list<CBase*> pTaskList) //归还任务
{
 {
  CAutoSynchronizer Syncher(m_TaskLock);
        list<CBase*>::iterator iter;
        for(iter = pTaskList.begin();iter != pTaskList.end(); ++iter)
        {
            CBase *pBaseTask = (*iter);
            AddTask(pBaseTask);
        }
 }
}

void CThreadPool::AddTask(CBase *pBaseTask)
{
 if(m_bStoped)
 { 
  cout<<"-----The threadpool is destroyed. /n";
  return;
 }
 CAutoSynchronizer Syncher(m_TaskLock);
 m_TaskList.push_back(pBaseTask);
}

int CThreadPool::GetTaskCount()
{
    printf("GetTaskCount开始/n");
 CAutoSynchronizer Syncher(m_TaskLock);
    printf("GetTaskCount结束/n");
    int nSize = m_TaskList.size();
 return nSize;
}

void CThreadPool::JoinWithAllThreads()
{
    for(int i = 0; i < m_ThreadList.Count();i++)
    {
        CWorkThread *pThread = NULL;
        pThread = (CWorkThread*)m_ThreadList[i];
        pThread->WaitFor();
    }
}

void CThreadPool::Execute(void)
{
 CWorkThread *pThread =  NULL;
 while(!GetTerminated())
 {
  Sleep(0.01);
        pThread = GetIdleThread();// 检查空闲线程队列

        if( pThread != NULL )
        {
            if( CheckNewTask() )  // 有新任务
   {
                if(pThread->GetThreadState() == 2)
                {
     int j = SjwResumeThread(pThread);
                    if(j > 0)
                    {
      pThread->SetThreadState(1);
                    }
     else
     {
      continue;
                    }
                }
                else
    {
     if(pThread->GetThreadState() != 1)
     {
      cout<<"线程状态等于="<<pThread->GetThreadState()<<endl;
      continue;
     }
                }
    list<CBase*> pTaskList;
    GetTask(pTaskList); // 取得一定数量的任务
    AddTaskToThread(pTaskList, pThread);// 把任务传入线程
    m_nLastTime = GetCurTicks();
    continue; // 继续循环
   }
   else
   {
             UpdateThread();
   }
        }
        if( pThread == NULL && m_ThreadList.Count() < m_nMaxSize )// 没有空闲线程了
        {
            CreateNewThread();// 创建新线程
            m_nLastTime = GetCurTicks();
            continue;// 继续循环
        }
        // 没有要处理的任务或者已经到达线程数的上限，进入超时等待
        if( WaitForTaskOrThreadTimeout() )
        {
            if( IncrIdleTime() > m_nTime )    // 系统空闲，计时
            {
                // 系统长时间处于空闲，销毁一定数量的空闲线程
                DecrIdleThread();
            }
        }
        else
        {
   printf("线程休息，原因是没有要处理的任务或者已经到达线程数的上限,已经超时结束/n");
   printf("%d/n",GetTaskCount());
            Sleep(0.1);
        }
    }

}

void CThreadPool::AddTaskToThread(list<CBase*> pTaskList,CWorkThread *pThread)
{
 pThread->SetTaskList(pTaskList);
 pThread->SetThreadState(0);
}

void CThreadPool::CreateNewThread()
{
    CAutoSynchronizer Syncher(m_ThreadLock);
    CWorkThread *hThread = new CWorkThread(this);
    m_ThreadList.Add(hThread);
    hThread->Run();
}

void CThreadPool::UpdateThread()
{
    CAutoSynchronizer Syncher(m_ThreadLock);
 for (int i = 0; i < m_ThreadList.Count(); i++)
    {
        CWorkThread *pThread = NULL;
        pThread=(CWorkThread*)m_ThreadList[i];
        if(pThread->GetThreadState() == 1)
        {
            int j = SjwSuspendThread(pThread);
            if(j >=0)
            {
                pThread->SetThreadState(2);
            }
        }
    }
}


unsigned int CThreadPool::GetThreadCount(void)
{
 CAutoSynchronizer Syncher(m_ThreadLock);
 return m_ThreadList.Count();
}

long CThreadPool::IncrIdleTime()
{
    return (GetCurTicks() - m_nLastTime);
}

void CThreadPool::DecrIdleThread()
{
    const int MAX_THREAD_WAIT_FOR_SECS = 10; // 线程池清空时最多等待时间(秒)
    const double SLEEP_INTERVAL = 0.5;      // 每次等待的时间间隔(秒)
    double nWaitSecs = 0;
    bool bFlag = false;
    int index = -1;
    // 通知线程退出
    {
        CAutoSynchronizer Syncher(m_ThreadLock);

        for (int i = m_ThreadList.Count()-1; i>= 0 && m_ThreadList.Count() > m_nSize; i--)
        {
            CWorkThread *pThread;
            pThread = (CWorkThread*)m_ThreadList[i];
            if(pThread->GetThreadState() == 2)
            {
                pThread->Terminate();
                bFlag = true;
                index = i;
                break;
            }
        }
    }
    // 等待线程退出
    while (nWaitSecs < MAX_THREAD_WAIT_FOR_SECS && bFlag)
    {
        if (m_ThreadList.Count() == 0) break;
        NanoSleep(SLEEP_INTERVAL, true);
        nWaitSecs += SLEEP_INTERVAL;
    }

    // 若等待超时，则强行杀死各线程
    if (m_ThreadList.Count() > 0 && bFlag)
    {
        CAutoSynchronizer Syncher(m_ThreadLock);
        CWorkThread *pThread;
        pThread = (CWorkThread*)m_ThreadList[index];
        pThread->Kill();
        m_ThreadList.Delete(index);
    }

}

bool CThreadPool::WaitForTaskOrThreadTimeout()
{
    Sleep(0.1);
    return true;
}

CWorkThread* CThreadPool::GetIdleThread()
{

    CAutoSynchronizer Syncher(m_ThreadLock);
    CWorkThread *pThread = NULL;
    for (int i = 0; i < m_ThreadList.Count(); i++)
    {
        if(((CWorkThread*)m_ThreadList[i])->GetThreadState() == 2 ||  ((CWorkThread*)m_ThreadList[i])->GetThreadState() == 1)
        {
            pThread=(CWorkThread*)m_ThreadList[i];
            break;
        }
    }
    return pThread;
}

bool CThreadPool::SetThreadTask(list<CBase*> pTaskList)
{
    CAutoSynchronizer Syncher(m_ThreadLock);
    bool bThread = false;
    CWorkThread *pThread = NULL;
    for (int i = 0; i < m_ThreadList.Count(); i++)
    {
        if(((CWorkThread*)m_ThreadList[i])->GetThreadState() == 2)
        {
            pThread=(CWorkThread*)m_ThreadList[i];
            int j = SjwResumeThread(pThread);
            if(j > 0)
            {
                pThread->SetThreadState(1);
            }
            else
            {
                continue;
            }
            m_ThreadList.Delete(i);
            AddTaskToThread(pTaskList, pThread);// 把任务传入线程
            bThread = true;
            break;
        }
        else if(((CWorkThread*)m_ThreadList[i])->GetThreadState() == 1)
        {
            pThread=(CWorkThread*)m_ThreadList[i];
            AddTaskToThread(pTaskList, pThread);// 把任务传入线程
            bThread = true;
            break;   
        }
    }
    return bThread;
}

bool CThreadPool::CheckNewTask()
{
    return !TaskIsEmpty();   
}

int CThreadPool::SjwSuspendThread(CWorkThread * pThread)
{
    return SuspendThread(pThread->GetHandle());
}

int CThreadPool::SjwResumeThread(CWorkThread * pThread)
{
    return ResumeThread(pThread->GetHandle());
}

bool CThreadPool::PoolFree()
{
    CAutoSynchronizer Syncher(m_TaskLock);
    if(m_TaskList.size() > 50)
    {
        return false;
    }
    return true;
}


CWorkThread::CWorkThread(const CThreadPool * _threadPool): m_pool(const_cast<CThreadPool *> (_threadPool)),m_pBaseTask(NULL)
,m_bThreadExit(false),m_bThreadExitFlag(false),m_nThreadState(0)
{
    m_Queue.clear();   
}

CWorkThread::~CWorkThread()
{
 if(m_pBaseTask != NULL)
    {
  delete m_pBaseTask;
        m_pBaseTask = NULL;
    }
 deque<CBase*>::iterator iter;
    for(iter = m_Queue.begin();iter != m_Queue.end();++iter)
    {
        CBase *pTemp = *iter;
        delete pTemp;
    }
}

void CWorkThread::Execute(void)
{
 while(!GetTerminated())
    {
        // 检查任务队列是否有任务要运行
        if( CheckTaskQueue() )                                                                                                                                                                                                                                                                                                       
  {
   if(m_nThreadState == 0)
   {
             // 队列中没有任务
    m_pool->OnTaskIdle(this); // 通知线程池，此线程已经空闲
   }
            if( WaitForTask())
                continue;// 继续循环
            else
               break;
        }
        else
        {
            // 有任务需要运行
   m_pBaseTask = GetTask(); // 取得新任务
            if(m_pBaseTask != NULL)
            {
                try
                {
                    while(!GetTerminated())
                    {
      int nRun = m_pBaseTask->Run(this->GetThreadId());
                        if(nRun == 0)
                        {
                            Sleep(0.02);
                            continue;
                        }
                        else if(nRun == 1)
                        {
                         break;
      }
      //break;
                    }
                   
                }
                catch(...)
                {

                }
    delete m_pBaseTask; // 任务执行完毕,删除此任务
    m_pBaseTask  = NULL;
            }

        }
    }
    m_bThreadExitFlag = true;
}

void CWorkThread::SetTaskList(list<CBase*> pTaskList)
{
    CAutoSynchronizer Syncher(m_Lock);
 list<CBase*>::iterator iter;
    for(iter = pTaskList.begin();iter != pTaskList.end();++iter)
    {
  m_Queue.push_back(*iter);
    }
 pTaskList.clear();
}

bool  CWorkThread::WaitForTask()
{
     if(!m_bThreadExit)
     {
  Sleep(0.1);
        return true;
     }
     else
        return false;
}


bool  CWorkThread::CheckTaskQueue()
{
 CAutoSynchronizer Syncher(m_Lock);
 return m_Queue.empty();
}

CBase* CWorkThread::GetTask()
{
   CBase *pBaseTask = NULL;
 {
        CAutoSynchronizer Syncher(m_Lock);
  pBaseTask = m_Queue.front();
        if(pBaseTask)
        {
            m_Queue.pop_front();
        }
 }
 return pBaseTask;
}

 

上面代码问题就是 线程池任务分配线程和工作者线程有死锁的现象,大家帮我看看,谢谢!!!

tdjdyq
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
高性能动态可扩展伸缩的线程池
04-28
高性能动态可扩展伸缩的线程池,对服务器开发很有帮助，好不好直接看代码吧，其他不说了
初识pthread（一）-线程管理之创建/结束线程
田元的专栏
02-24 810
进阶的线程学习---pthread！
pthread终止线程（linux编程）
Savage888777的博客
05-10 1436
linux终止线程 正常情况下，线程一旦创建便从指定函数开始执行直到该函数返回。一旦该函数返回，这些线程便自行终止。线程也可以在执行的途中通过调用pthread_exit()终止自己的执行。实际上，非初始线程（这里只main函数的线程）从开始函数返回是返回到线程库中，由线程库隐含地调用函数pthread_exit()，并用开始函数的返回值作为线程的出口状态。但是，初始线程则不然。初始线程如果也调用相同的开始函数，在这个函数没有明显调用pthread_exit()的情况下，它将正常返回到其调用点。 线程终止并
线程学习之三_线程结束
安静睡觉
01-01 602
线程可以通过下面的方法来结束执行： 1、从线程的第一个函数(本线程开始执行的函数)返回； 2、调用pthread_exit()函数； 3、从main()函数中调用返回或者调用exit()； 4、使用取消函数执行终止操作。
Java可扩展线程池-ThreadPoolExecutor
欲望以提升热忱 毅力以磨平高山
06-11 919
1、ThreadPoolExecutor 我们知道ThreadPoolExecutor是可扩展的，它提供了几个可以在子类中改写的空方法如下： protected void beforeExecute(Thread t, Runnable r) { } protected void afterExecute(Runnable r, Throwable t) { } protec...
利用C++语言设计可扩展线程池
aikker的专栏
01-19 500
来源：阿蒙编程之家   摘要：在各种业务解决方案的设计中，服务器处理任务的效率是衡量方案优劣的一个重要标准。使用多线程技术并发处理任务是提高服务器效率的一个主要手段。但是频繁的线程创建、销毁和任务的分配也会降低系统效率。本文设计了一个通用的线程池，根据不同服务器所处理的任务的特点，可以设置对应的线程池参数，最大幅度的提高系统性能。　　关键字：线程池多线程任务虚函数异常　
c++线程池经典实现方式demo
05-10
c++线程池经典实现方式demo
C++语言实现的线程池，结合windowsIOCP完成端口，实现socket高并发服务端程序.zip
10-19
C++语言实现的线程池，结合windowsIOCP完成端口，实现socket高并发服务端程序.zip
c++线程池实现方法
12-31
本文实例讲述了c++线程池实现方法。分享给大家供大家参考。具体分析如下： 下面这个线程池是我在工作中用到过的，原理还是建立一个任务队列，让多个线程互斥的在队列中取出任务，然后执行，显然，队列是要加锁的 ...
线程池原理及创建（C++实现
01-27
线程池原理及创建（C++实现）
一种简单的可扩展的序列化方法（C++）
09-23
参考protobuf设计的一种简单的序列化方法，支持自己扩展，且扩展简单
linux线程池代码（c++实现）
04-15
linux线程池代码（c++实现） 分两部： 1、创建线程池 2、创建任务、加入线程池 可以参考使用
C 练习实例36 - 求100之内的素数
2401_82561004的博客
04-27 972
质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。// Copyright © 2013年 编程字典. All rights reserved.求100之内的素数。
C#(C Sharp)学习笔记_类【十五】
最新发布
追求细节，成就完美
05-01 188
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 1003
C++ Primer (第五版）第八章习题部分答案
手搓顺序表（C语言）
m0_62646213的博客
04-23 696
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c入门基础题（3）
梦昼初
04-26 893
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
用c++代码来实现一个线程池
07-12
当然，我可以为您提供一个简单的C++代码示例来实现一个线程池。以下是一个基本的线程池实现： ```cpp #include #include #include #include #include class ThreadPool { public: ThreadPool(size_t ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值