• 一个C++基于boost简单实现的线程池


    xl_blocking_queue.h

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    #ifndef SRC_COMMON_BLOCKING_QUEUE_H_
    #define SRC_COMMON_BLOCKING_QUEUE_H_
    #include <boost/thread.hpp>
    #include <boost/noncopyable.hpp>
    #include <queue>
     
    template<typename T>
    class xl_blocking_queue
      :boost::noncopyable
    {
    public:
      xl_blocking_queue()
        :mutex_(), queue_(), cond_()
      {
       
      }
      ~xl_blocking_queue(){}
     
      void put(const T& func)
      {
        boost::unique_lock<boost::mutex> lock(mutex_);
        queue_.push(func);
        cond_.notify_all();
      }
     
      T get()
      {
        boost::unique_lock<boost::mutex> lock(mutex_);
        if (queue_.size() == 0)
        {
          cond_.wait(lock);
        }
        T front(queue_.front());
        queue_.pop();
        return front;
      }
     
      unsigned size()
      {
        return queue_.size();
      }
     
      void notify_all()
      {
        cond_.notify_all();
      }
    private:
      std::queue<T> queue_;
      boost::condition_variable_any cond_;
      boost::mutex mutex_;
    };
     
     
    #endif

    xl_thread_pool.h

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    <strong>#ifndef SRC_COMMON_THREAD_POOL_H_
    #define SRC_COMMON_THREAD_POOL_H_
    #include <boost/thread.hpp>
    #include <boost/shared_ptr.hpp>
    #include <boost/noncopyable.hpp>
     
    #include <vector>
    #include "xl_blocking_queue.h"
     
    typedef boost::function<void (void)> thread_do_func;
     
    class xl_thread_pool
      :boost::noncopyable
    {
    public:
      xl_thread_pool(int thread_num)
        :num_(thread_num), run_(false)
      {
         
      }
      ~xl_thread_pool()
      {
        if (run_)
        {
          stop();
        }
      }
     
      void start()
      {
        if (num_ <= 0) return;
        int i = 0;
        run_ = true;
        for(i=0;i<num_;i++)
        {
          boost::shared_ptr<boost::thread> thread(new boost::thread(boost::BOOST_BIND(&xl_thread_pool::run, this)));
          thread_arr_.push_back(thread);
        }
      }
     
      void stop()
      {
        run_ = false;
        queue_.notify_all();
      }
     
      void post(const thread_do_func& task)
      {
        if (thread_arr_.size() == 0)
        {
          task();
        }
        else
        {
          queue_.put(task);
        }   
      }
    private:
      xl_blocking_queue<thread_do_func> queue_;
      std::vector<boost::shared_ptr<boost::thread> > thread_arr_;
      int num_;
      bool run_;
     
      void run()
      {
        while(run_)
        {
          thread_do_func task = queue_.get();
          task();
        }
      }
    };
     
     
    #endif
  • 相关阅读:
    EL表达式
    Java反射机制详解
    最小生成树-Prim算法和Kruskal算法
    最短路径—Dijkstra算法和Floyd算法
    servlet的转发与重定向
    SQL常用增删改查
    Java map遍历
    深入理解Java的接口和抽象类
    eclipse快捷键
    Vue父子组件数据双向绑定,子组件可修改props
  • 原文地址:https://www.cnblogs.com/lvdongjie/p/4494065.html
Copyright © 2020-2023  润新知