Boost库实现线程池实例

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #ifndef MY_TASK_QUEUE_H   
  2. #define MY_TASK_QUEUE_H   
  3. #include <queue>   
  4. #include <boost/thread.hpp>   
  5. #include <boost/noncopyable.hpp>   
  6. #include <boost/function.hpp>   
  7. //using namespace boost;   
  8. //using namespace std;   
  9. typedef boost::function<void(void)> my_task;  
  10. //任务队列   
  11. class Task_queue:boost::noncopyable  
  12. {  
  13. private:  
  14.     std::queue<my_task> my_queue;  
  15.     boost::condition_variable_any cond;  
  16.     boost::mutex my_mutex;  
  17. public:  
  18.     void push_task(const my_task & task_func)  
  19.     {  //加上互斥锁   
  20.         boost::unique_lock<boost::mutex> lock(my_mutex);  
  21.         my_queue.push(task_func);  
  22.         //通知其他线程启动   
  23.         cond.notify_one();  
  24.     }  
  25.     my_task get_task(){  
  26.         //加上互斥锁   
  27.         boost::unique_lock<boost::mutex> lock(my_mutex);  
  28.         if(my_queue.size()==0)  
  29.         {  
  30.             //如果队列中没有任务，则等待互斥锁   
  31.             cond.wait(lock);  
  32.         }  
  33.         //指向队列首部   
  34.         my_task task(my_queue.front());  
  35.         //出队列   
  36.         my_queue.pop();  
  37.         return task;        
  38.     }  
  39.     int get_size()  
  40.     {  
  41.         return my_queue.size();  
  42.     }  
  43. };  
  44.   
  45. #endif    
#ifndef MY_TASK_QUEUE_H
#define	MY_TASK_QUEUE_H
#include <queue>
#include <boost/thread.hpp>
#include <boost/noncopyable.hpp>
#include <boost/function.hpp>
//using namespace boost;
//using namespace std;
typedef boost::function<void(void)> my_task;
//任务队列
class Task_queue:boost::noncopyable
{
private:
    std::queue<my_task> my_queue;
    boost::condition_variable_any cond;
    boost::mutex my_mutex;
public:
    void push_task(const my_task & task_func)
    {  //加上互斥锁
        boost::unique_lock<boost::mutex> lock(my_mutex);
        my_queue.push(task_func);
        //通知其他线程启动
        cond.notify_one();
    }
    my_task get_task(){
        //加上互斥锁
        boost::unique_lock<boost::mutex> lock(my_mutex);
        if(my_queue.size()==0)
        {
            //如果队列中没有任务，则等待互斥锁
            cond.wait(lock);
        }
        //指向队列首部
        my_task task(my_queue.front());
        //出队列
        my_queue.pop();
        return task;      
    }
    int get_size()
    {
        return my_queue.size();
    }
};

#endif

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #ifndef MY_THREAD_POOL_H   
  2. #define MY_THREAD_POOL_H   
  3. #include <boost/thread.hpp>   
  4. #include <boost/noncopyable.hpp>   
  5. #include <boost/function.hpp>   
  6. #include "My_Task_queue.h"   
  7. #include <iostream>   
  8. using namespace std;  
  9. class My_thread_pool:boost::noncopyable  
  10. {  
  11. private:  
  12.     //线程队列   
  13.     Task_queue my_queue;  
  14.     //线程组   
  15.     boost::thread_group my_thread_group;  
  16.     int thread_num;  
  17.     volatile bool is_run;  
  18.     void run()  
  19.     {  
  20.         while(is_run)  
  21.         {  
  22.             cout<<"run "<<endl;  
  23.             //一直处理线程池的任务   
  24.             my_task task=my_queue.get_task();  
  25.             task();  
  26.         }  
  27.     }  
  28. public:  
  29.     My_thread_pool(int num):thread_num(num),is_run(false)  
  30.     {  
  31.           
  32.     };  
  33.     ~My_thread_pool(){  
  34.       
  35.     };  
  36.     void init()  
  37.     {  
  38.         is_run=true;  
  39.         if(thread_num<=0)  
  40.         {  
  41.             return ;  
  42.         }  
  43.         for(int i=0;i<thread_num;++i)  
  44.         {  
  45.             //生成多个线程，绑定run函数，添加到线程组   
  46.             my_thread_group.add_thread(new boost::thread(boost::bind(&My_thread_pool::run,this)));  
  47.         }  
  48.     }  
  49.     //停止线程池   
  50.     void stop()  
  51.     {  
  52.         is_run=false;  
  53.     }  
  54.     //添加任务    
  55.     void post(const my_task &task)  
  56.     {  
  57.         my_queue.push_task(task);  
  58.     }  
  59.     void wait()  
  60.     {  
  61.         my_thread_group.join_all();  
  62.     }  
  63.                 
  64. };  
  65. #endif    
#ifndef MY_THREAD_POOL_H
#define	MY_THREAD_POOL_H
#include <boost/thread.hpp>
#include <boost/noncopyable.hpp>
#include <boost/function.hpp>
#include "My_Task_queue.h"
#include <iostream>
using namespace std;
class My_thread_pool:boost::noncopyable
{
private:
    //线程队列
    Task_queue my_queue;
    //线程组
    boost::thread_group my_thread_group;
    int thread_num;
    volatile bool is_run;
    void run()
    {
        while(is_run)
        {
            cout<<"run "<<endl;
            //一直处理线程池的任务
            my_task task=my_queue.get_task();
            task();
        }
    }
public:
    My_thread_pool(int num):thread_num(num),is_run(false)
    {
        
    };
    ~My_thread_pool(){
    
    };
    void init()
    {
        is_run=true;
        if(thread_num<=0)
        {
            return ;
        }
        for(int i=0;i<thread_num;++i)
        {
            //生成多个线程，绑定run函数，添加到线程组
            my_thread_group.add_thread(new boost::thread(boost::bind(&My_thread_pool::run,this)));
        }
    }
    //停止线程池
    void stop()
    {
        is_run=false;
    }
    //添加任务 
    void post(const my_task &task)
    {
        my_queue.push_task(task);
    }
    void wait()
    {
        my_thread_group.join_all();
    }
              
};
#endif
[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #include "My_Task_queue.h"   
  2. #include "My_thread_pool.h"   
  3. #include <iostream>   
  4. #include <cstdlib>   
  5. using namespace std;  
  6.   
  7. void print_task(int i)  
  8. {  
  9.     cout<<"I am Task "<<i<<" number:"<<endl;  
  10. }  
  11. //使用boost线程池  编译参数加上-lboost_thread   
  12. int main(int argc, char** argv) {  
  13.   
  14.     My_thread_pool tp(4);  
  15.     tp.init();  
  16.       
  17.     my_task task[4];  
  18.     for(int i=0;i<4;i++)  
  19.     {  
  20.         //生成线程任务,类型为函数指针 boost::function<void(void)>   
  21.         task[i]=boost::bind(print_task,i+1);  
  22.         //放到线程池中处理   
  23.         tp.post(task[i]);  
  24.     }  
  25.     //等待线程池处理完成！   
  26.    tp.wait();  
  27.       
  28.     return 0;  
  29. }  
posted @ 2022-03-12 22:05  xiaomodecnblogs  阅读(147)  评论(0)  编辑  收藏  举报