博主在他的博客里对taskqueue的各种使用情况和使用方法都介绍的很清楚：http://www.cnblogs.com/zhiranok/archive/2013/01/14/task_queue.html

先把代码贴上，之后研究：

  1. #ifndef _TASK_QUEUE_I_
  2. #define _TASK_QUEUE_I_
  3.  
  4. #include <list>
  5. #include <vector>
  6. using namespace std;
  7.  
  8. namespace ff {
  9.  
  10. typedef void (*task_func_t)(void*);
  11.  
  12. class task_impl_i
  13. {
  14. public:
  15.     virtual ~task_impl_i(){}
  16.     virtual void run()          = 0;
  17.     virtual task_impl_i* fork() = 0;
  18. };
  19.  
  20. class task_impl_t: public task_impl_i
  21. {
  22. public:
  23.     task_impl_t(task_func_t func_, void* arg_):
  24.         m_func(func_),
  25.         m_arg(arg_)
  26.     {}
  27.  
  28.     virtual void run()
  29.     {
  30.         m_func(m_arg);
  31.     }
  32.  
  33.     virtual task_impl_i* fork()
  34.     {
  35.         return new task_impl_t(m_func, m_arg);
  36.     }
  37.  
  38. protected:
  39.     task_func_t m_func;
  40.     void*       m_arg;
  41. };
  42.  
  43. struct task_t
  44. {
  45.     static void dumy(void*){}
  46.     task_t(task_func_t f_, void* d_):
  47.         task_impl(new task_impl_t(f_, d_))
  48.     {
  49.     }
  50.     task_t(task_impl_i* task_imp_):
  51.         task_impl(task_imp_)
  52.     {
  53.     }
  54.     task_t(const task_t& src_):
  55.         task_impl(src_.task_impl->fork())
  56.     {
  57.     }
  58.     task_t()
  59.     {
  60.         task_impl = new task_impl_t(&task_t::dumy, NULL);
  61.     }
  62.     ~task_t()
  63.     {
  64.         delete task_impl;
  65.     }
  66.     task_t& operator=(const task_t& src_)
  67.     {
  68.         delete task_impl;
  69.         task_impl = src_.task_impl->fork();
  70.         return *this;
  71.     }
  72.  
  73.     void run()
  74.     {
  75.         task_impl->run();
  76.     }
  77.     task_impl_i*    task_impl;
  78. };
  79.  
  80. class task_queue_i
  81. {
  82. public:
  83.     typedef list<task_t> task_list_t;
  84. public:
  85.     virtual ~task_queue_i(){}
  86.     virtual void close() = 0;
  87.     virtual void produce(const task_t& task_) =0;
  88.     virtual void multi_produce(const task_list_t& task_) =0;
  89.     virtual int  consume(task_t& task_) = 0;
  90.     virtual int  consume_all(task_list_t&) = 0;
  91.     virtual int run() = 0;
  92.     virtual int batch_run() = 0;
  93. };
  94.  
  95. struct task_binder_t
  96. {
  97.     //! C function
  98.  
  99.     static task_t gen(void (*func_)(void*), void* p_)
  100.     {
  101.         return task_t(func_, p_);
  102.     }
  103.     template<typename RET>
  104.     static task_t gen(RET (*func_)(void))
  105.     {
  106.         struct lambda_t
  107.         {
  108.             static void task_func(void* p_)
  109.             {
  110.                 (*(RET(*)(void))p_)();
  111.             };
  112.         };
  113.         return task_t(lambda_t::task_func, (void*)func_);
  114.     }
  115.     template<typename FUNCT, typename ARG1>
  116.     static task_t gen(FUNCT func_, ARG1 arg1_)
  117.     {
  118.         struct lambda_t: public task_impl_i
  119.         {
  120.             FUNCT dest_func;
  121.             ARG1  arg1;
  122.             lambda_t(FUNCT func_, const ARG1& arg1_):
  123.                 dest_func(func_),
  124.                 arg1(arg1_)
  125.             {}
  126.             virtual void run()
  127.             {
  128.                 (*dest_func)(arg1);
  129.             }
  130.             virtual task_impl_i* fork()
  131.             {
  132.                 return new lambda_t(dest_func, arg1);
  133.             }
  134.         };
  135.         return task_t(new lambda_t(func_, arg1_));
  136.     }
  137.     template<typename FUNCT, typename ARG1, typename ARG2>
  138.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_)
  139.     {
  140.         struct lambda_t: public task_impl_i
  141.         {
  142.             FUNCT dest_func;
  143.             ARG1 arg1;
  144.             ARG2 arg2;
  145.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_):
  146.                 dest_func(func_),
  147.                 arg1(arg1_),
  148.                 arg2(arg2_)
  149.             {}
  150.             virtual void run()
  151.             {
  152.                 (*dest_func)(arg1, arg2);
  153.             }
  154.             virtual task_impl_i* fork()
  155.             {
  156.                 return new lambda_t(dest_func, arg1, arg2);
  157.             }
  158.         };
  159.         return task_t(new lambda_t(func_, arg1_, arg2_));
  160.     }
  161.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3>
  162.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
  163.     {
  164.         struct lambda_t:public task_impl_i
  165.         {
  166.             FUNCT dest_func;
  167.             ARG1 arg1;
  168.             ARG2 arg2;
  169.             ARG3 arg3;
  170.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
  171.                 dest_func(func_),
  172.                 arg1(arg1_),
  173.                 arg2(arg2_),
  174.                 arg3(arg3_)
  175.             {}
  176.             virtual void run()
  177.             {
  178.                 (*dest_func)(arg1, arg2, arg3);
  179.             }
  180.             virtual task_impl_i* fork()
  181.             {
  182.                 return new lambda_t(dest_func, arg1, arg2, arg3);
  183.             }
  184.         };
  185.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_));
  186.     }
  187.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4>
  188.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
  189.     {
  190.         struct lambda_t: public task_impl_i
  191.         {
  192.             FUNCT dest_func;
  193.             ARG1 arg1;
  194.             ARG2 arg2;
  195.             ARG3 arg3;
  196.             ARG4 arg4;
  197.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_):
  198.                 dest_func(func_),
  199.                 arg1(arg1_),
  200.                 arg2(arg2_),
  201.                 arg3(arg3_),
  202.                 arg4(arg4_)
  203.             {}
  204.             virtual void run()
  205.             {
  206.                 (*dest_func)(arg1, arg2, arg3, arg4);
  207.             }
  208.             virtual task_impl_i* fork()
  209.             {
  210.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4);
  211.             }
  212.         };
  213.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_));
  214.     }
  215.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
  216.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
  217.     {
  218.         struct lambda_t: public task_impl_i
  219.         {
  220.             FUNCT dest_func;
  221.             ARG1 arg1;
  222.             ARG2 arg2;
  223.             ARG3 arg3;
  224.             ARG4 arg4;
  225.             ARG5 arg5;
  226.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  227.                      const ARG5& arg5_):
  228.                 dest_func(func_),
  229.                 arg1(arg1_),
  230.                 arg2(arg2_),
  231.                 arg3(arg3_),
  232.                 arg4(arg4_),
  233.                 arg5(arg5_)
  234.             {}
  235.             virtual void run()
  236.             {
  237.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5);
  238.             }
  239.             virtual task_impl_i* fork()
  240.             {
  241.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5);
  242.             }
  243.         };
  244.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_));
  245.     }
  246.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
  247.     static task_t gen(FUNCT func_,
  248.                        ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  249.                        ARG5 arg5_, ARG6 arg6_)
  250.     {
  251.         struct lambda_t: public task_impl_i
  252.         {
  253.             FUNCT dest_func;
  254.             ARG1 arg1;
  255.             ARG2 arg2;
  256.             ARG3 arg3;
  257.             ARG4 arg4;
  258.             ARG5 arg5;
  259.             ARG6 arg6;
  260.             lambda_t(FUNCT func_,
  261.                      const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  262.                      const ARG5& arg5_, const ARG6& arg6_):
  263.                 dest_func(func_),
  264.                 arg1(arg1_),
  265.                 arg2(arg2_),
  266.                 arg3(arg3_),
  267.                 arg4(arg4_),
  268.                 arg5(arg5_),
  269.                 arg6(arg6_)
  270.             {}
  271.             virtual void run()
  272.             {
  273.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
  274.             }
  275.             virtual task_impl_i* fork()
  276.             {
  277.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6);
  278.             }
  279.         };
  280.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
  281.     }
  282.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
  283.             typename ARG7>
  284.     static task_t gen(FUNCT func_,
  285.                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  286.                       ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
  287.     {
  288.         struct lambda_t: public task_impl_i
  289.         {
  290.             FUNCT dest_func;
  291.             ARG1 arg1;
  292.             ARG2 arg2;
  293.             ARG3 arg3;
  294.             ARG4 arg4;
  295.             ARG5 arg5;
  296.             ARG6 arg6;
  297.             ARG7 arg7;
  298.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  299.                      const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
  300.                 dest_func(func_),
  301.                 arg1(arg1_),
  302.                 arg2(arg2_),
  303.                 arg3(arg3_),
  304.                 arg4(arg4_),
  305.                 arg5(arg5_),
  306.                 arg6(arg6_),
  307.                 arg7(arg7_)
  308.             {}
  309.             virtual void run()
  310.             {
  311.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  312.             }
  313.             virtual task_impl_i* fork()
  314.             {
  315.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  316.             }
  317.         };
  318.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
  319.     }
  320.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
  321.             typename ARG7, typename ARG8>
  322.     static task_t gen(FUNCT func_,
  323.                        ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  324.                        ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
  325.     {
  326.         struct lambda_t: public task_impl_i
  327.         {
  328.             FUNCT dest_func;
  329.             ARG1 arg1;
  330.             ARG2 arg2;
  331.             ARG3 arg3;
  332.             ARG4 arg4;
  333.             ARG5 arg5;
  334.             ARG6 arg6;
  335.             ARG7 arg7;
  336.             ARG8 arg8;
  337.             lambda_t(FUNCT func_,
  338.                      const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  339.                      const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
  340.                 dest_func(func_),
  341.                 arg1(arg1_),
  342.                 arg2(arg2_),
  343.                 arg3(arg3_),
  344.                 arg4(arg4_),
  345.                 arg5(arg5_),
  346.                 arg6(arg6_),
  347.                 arg7(arg7_),
  348.                 arg8(arg8_)
  349.             {}
  350.             virtual void run()
  351.             {
  352.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  353.             }
  354.             virtual task_impl_i* fork()
  355.             {
  356.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  357.             }
  358.         };
  359.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
  360.     }
  361.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
  362.             typename ARG7, typename ARG8, typename ARG9>
  363.     static task_t gen(FUNCT func_,
  364.                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  365.                       ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
  366.     {
  367.         struct lambda_t: public task_impl_i
  368.         {
  369.             FUNCT dest_func;
  370.             ARG1 arg1;
  371.             ARG2 arg2;
  372.             ARG3 arg3;
  373.             ARG4 arg4;
  374.             ARG5 arg5;
  375.             ARG6 arg6;
  376.             ARG7 arg7;
  377.             ARG8 arg8;
  378.             ARG9 arg9;
  379.             lambda_t(FUNCT func_,
  380.                      const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  381.                      const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_, const ARG9& arg9_):
  382.                 dest_func(func_),
  383.                 arg1(arg1_),
  384.                 arg2(arg2_),
  385.                 arg3(arg3_),
  386.                 arg4(arg4_),
  387.                 arg5(arg5_),
  388.                 arg6(arg6_),
  389.                 arg7(arg7_),
  390.                 arg8(arg8_),
  391.                 arg9(arg9_)
  392.             {}
  393.             virtual void run()
  394.             {
  395.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  396.             }
  397.             virtual task_impl_i* fork()
  398.             {
  399.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  400.             }
  401.         };
  402.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
  403.     }
  404.     //! class fuctions
  405.     template<typename T, typename RET>
  406.     static task_t gen(RET (T::*func_)(void), T* obj_)
  407.     {
  408.         struct lambda_t:public task_impl_i
  409.         {
  410.             RET (T::*dest_func)(void);
  411.             T* obj;
  412.             lambda_t(RET (T::*func_)(void), T* obj_):
  413.                 dest_func(func_),
  414.                 obj(obj_)
  415.             {}
  416.             virtual void run()
  417.             {
  418.                 (obj->*dest_func)();
  419.             }
  420.             virtual task_impl_i* fork()
  421.             {
  422.                 return new lambda_t(dest_func, obj);
  423.             }
  424.         };
  425.         return task_t(new lambda_t(func_, obj_));
  426.     }
  427.     template<typename T, typename RET, typename FARG1, typename ARG1>
  428.     static task_t gen(RET (T::*func_)(FARG1), T* obj_, ARG1 arg1_)
  429.     {
  430.         struct lambda_t: public task_impl_i
  431.         {
  432.             RET (T::*dest_func)(FARG1);
  433.             T* obj;
  434.             ARG1 arg1;
  435.             lambda_t(RET (T::*func_)(FARG1), T* obj_, const ARG1& arg1_):
  436.                 dest_func(func_),
  437.                 obj(obj_),
  438.                 arg1(arg1_)
  439.             {}
  440.             virtual void run()
  441.             {
  442.                 (obj->*dest_func)(arg1);
  443.             }
  444.             virtual task_impl_i* fork()
  445.             {
  446.                 return new lambda_t(dest_func, obj, arg1);
  447.             }
  448.         };
  449.         return task_t(new lambda_t(func_, obj_, arg1_));
  450.     }
  451.     template<typename T, typename RET, typename FARG1, typename FARG2, typename ARG1, typename ARG2>
  452.     static task_t gen(RET (T::*func_)(FARG1, FARG2), T* obj_, ARG1 arg1_, ARG2 arg2_)
  453.     {
  454.         struct lambda_t:public task_impl_i
  455.         {
  456.             RET (T::*dest_func)(FARG1, FARG2);
  457.             T* obj;
  458.             ARG1 arg1;
  459.             ARG2 arg2;
  460.             lambda_t(RET (T::*func_)(FARG1, FARG2), T* obj_, const ARG1& arg1_, const ARG2& arg2_):
  461.                 dest_func(func_),
  462.                 obj(obj_),
  463.                 arg1(arg1_),
  464.                 arg2(arg2_)
  465.             {}
  466.             virtual void run()
  467.             {
  468.                 (obj->*dest_func)(arg1, arg2);
  469.             }
  470.             virtual task_impl_i* fork()
  471.             {
  472.                 return new lambda_t(dest_func, obj, arg1, arg2);
  473.             }
  474.         };
  475.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_));
  476.     }
  477.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename ARG1, typename ARG2,
  478.             typename ARG3>
  479.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
  480.     {
  481.         struct lambda_t:public task_impl_i
  482.         {
  483.             RET (T::*dest_func)(FARG1, FARG2, FARG3);
  484.             T* obj;
  485.             ARG1 arg1;
  486.             ARG2 arg2;
  487.             ARG3 arg3;
  488.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
  489.                 dest_func(func_),
  490.                 obj(obj_),
  491.                 arg1(arg1_),
  492.                 arg2(arg2_),
  493.                 arg3(arg3_)
  494.             {}
  495.             virtual void run()
  496.             {
  497.                 (obj->*dest_func)(arg1, arg2, arg3);
  498.             }
  499.             virtual task_impl_i* fork()
  500.             {
  501.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3);
  502.             }
  503.         };
  504.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_));
  505.     }
  506.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4,
  507.              typename ARG1, typename ARG2, typename ARG3, typename ARG4>
  508.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
  509.     {
  510.         struct lambda_t:public task_impl_i
  511.         {
  512.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4);
  513.             T* obj;
  514.             ARG1 arg1;
  515.             ARG2 arg2;
  516.             ARG3 arg3;
  517.             ARG4 arg4;
  518.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  519.                      const ARG3& arg3_, const ARG4& arg4_):
  520.                 dest_func(func_),
  521.                 obj(obj_),
  522.                 arg1(arg1_),
  523.                 arg2(arg2_),
  524.                 arg3(arg3_),
  525.                 arg4(arg4_)
  526.             {}
  527.             virtual void run()
  528.             {
  529.                 (obj->*dest_func)(arg1, arg2, arg3, arg4);
  530.             }
  531.             virtual task_impl_i* fork()
  532.             {
  533.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4);
  534.             }
  535.         };
  536.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_));
  537.     }
  538.     template<typename T, typename RET,  typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  539.             typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
  540.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, ARG1 arg1_, ARG2 arg2_,  ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
  541.     {
  542.         struct lambda_t: public task_impl_i
  543.         {
  544.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5);
  545.             T* obj;
  546.             ARG1 arg1;
  547.             ARG2 arg2;
  548.             ARG3 arg3;
  549.             ARG4 arg4;
  550.             ARG5 arg5;
  551.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  552.                      const ARG5& arg5_):
  553.                 dest_func(func_),
  554.                 obj(obj_),
  555.                 arg1(arg1_),
  556.                 arg2(arg2_),
  557.                 arg3(arg3_),
  558.                 arg4(arg4_),
  559.                 arg5(arg5_)
  560.             {}
  561.             virtual void run()
  562.             {
  563.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5);
  564.             }
  565.             virtual task_impl_i* fork()
  566.             {
  567.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5);
  568.             }
  569.         };
  570.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_));
  571.     }
  572.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  573.              typename FARG6, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
  574.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, ARG1 arg1_, ARG2 arg2_,
  575.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_)
  576.     {
  577.         struct lambda_t: public task_impl_i
  578.         {
  579.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6);
  580.             T* obj;
  581.             ARG1 arg1;
  582.             ARG2 arg2;
  583.             ARG3 arg3;
  584.             ARG4 arg4;
  585.             ARG5 arg5;
  586.             ARG6 arg6;
  587.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  588.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_):
  589.                 dest_func(func_),
  590.                 obj(obj_),
  591.                 arg1(arg1_),
  592.                 arg2(arg2_),
  593.                 arg3(arg3_),
  594.                 arg4(arg4_),
  595.                 arg5(arg5_),
  596.                 arg6(arg6_)
  597.             {}
  598.             virtual void run()
  599.             {
  600.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
  601.             }
  602.             virtual task_impl_i* fork()
  603.             {
  604.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6);
  605.             }
  606.         };
  607.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
  608.     }
  609.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  610.              typename FARG6, typename FARG7,
  611.              typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7>
  612.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, ARG1 arg1_, ARG2 arg2_,
  613.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
  614.     {
  615.         struct lambda_t: public task_impl_i
  616.         {
  617.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7);
  618.             T* obj;
  619.             ARG1 arg1;
  620.             ARG2 arg2;
  621.             ARG3 arg3;
  622.             ARG4 arg4;
  623.             ARG5 arg5;
  624.             ARG6 arg6;
  625.             ARG7 arg7;
  626.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  627.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
  628.                 dest_func(func_),
  629.                 obj(obj_),
  630.                 arg1(arg1_),
  631.                 arg2(arg2_),
  632.                 arg3(arg3_),
  633.                 arg4(arg4_),
  634.                 arg5(arg5_),
  635.                 arg6(arg6_),
  636.                 arg7(arg7_)
  637.             {}
  638.             virtual void run()
  639.             {
  640.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  641.             }
  642.             virtual task_impl_i* fork()
  643.             {
  644.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  645.             }
  646.         };
  647.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
  648.     }
  649.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  650.     typename FARG6, typename FARG7, typename FARG8,
  651.     typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7, typename ARG8>
  652.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, ARG1 arg1_, ARG2 arg2_,
  653.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
  654.     {
  655.         struct lambda_t: public task_impl_i
  656.         {
  657.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8);
  658.             T* obj;
  659.             ARG1 arg1;
  660.             ARG2 arg2;
  661.             ARG3 arg3;
  662.             ARG4 arg4;
  663.             ARG5 arg5;
  664.             ARG6 arg6;
  665.             ARG7 arg7;
  666.             ARG8 arg8;
  667.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  668.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
  669.                 dest_func(func_),
  670.                 obj(obj_),
  671.                 arg1(arg1_),
  672.                 arg2(arg2_),
  673.                 arg3(arg3_),
  674.                 arg4(arg4_),
  675.                 arg5(arg5_),
  676.                 arg6(arg6_),
  677.                 arg7(arg7_),
  678.                 arg8(arg8_)
  679.             {}
  680.             virtual void run()
  681.             {
  682.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  683.             }
  684.             virtual task_impl_i* fork()
  685.             {
  686.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  687.             }
  688.         };
  689.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
  690.     }
  691.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  692.             typename FARG6, typename FARG7, typename FARG8, typename FARG9,
  693.             typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,
  694.             typename ARG8, typename ARG9>
  695.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_, ARG1 arg1_, ARG2 arg2_,
  696.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
  697.     {
  698.         struct lambda_t: public task_impl_i
  699.         {
  700.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9);
  701.             T* obj;
  702.             ARG1 arg1;
  703.             ARG2 arg2;
  704.             ARG3 arg3;
  705.             ARG4 arg4;
  706.             ARG5 arg5;
  707.             ARG6 arg6;
  708.             ARG7 arg7;
  709.             ARG8 arg8;
  710.             ARG9 arg9;
  711.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_,
  712.                      const ARG1& arg1_, const ARG2& arg2_,
  713.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_,
  714.                      const ARG8& arg8_, const ARG9& arg9_):
  715.                 dest_func(func_),
  716.                 obj(obj_),
  717.                 arg1(arg1_),
  718.                 arg2(arg2_),
  719.                 arg3(arg3_),
  720.                 arg4(arg4_),
  721.                 arg5(arg5_),
  722.                 arg6(arg6_),
  723.                 arg7(arg7_),
  724.                 arg8(arg8_),
  725.                 arg9(arg9_)
  726.             {}
  727.             virtual void run()
  728.             {
  729.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  730.             }
  731.             virtual task_impl_i* fork()
  732.             {
  733.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  734.             }
  735.         };
  736.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
  737.     }
  738. };
  739.  
  740. }
  741.  
  742. #endif

　　

  1. #ifndef _TASK_QUEUE_IMPL_H_
  2. #define _TASK_QUEUE_IMPL_H_
  3.  
  4. #include<pthread.h>
  5. #include <list>
  6. #include <stdexcept>
  7. using namespace std;
  8.  
  9. #include "task_queue_i.h"
  10. #include "lock.h"
  11.  
  12. namespace ff {
  13. #ifndef _TASK_QUEUE_I_
  14. #define _TASK_QUEUE_I_
  15.  
  16. #include <list>
  17. #include <vector>
  18. using namespace std;
  19.  
  20. namespace ff {
  21.  
  22. typedef void (*task_func_t)(void*);
  23.  
  24. class task_impl_i
  25. {
  26. public:
  27.     virtual ~task_impl_i(){}
  28.     virtual void run()          = 0;
  29.     virtual task_impl_i* fork() = 0;
  30. };
  31.  
  32. class task_impl_t: public task_impl_i
  33. {
  34. public:
  35.     task_impl_t(task_func_t func_, void* arg_):
  36.         m_func(func_),
  37.         m_arg(arg_)
  38.     {}
  39.  
  40.     virtual void run()
  41.     {
  42.         m_func(m_arg);
  43.     }
  44.  
  45.     virtual task_impl_i* fork()
  46.     {
  47.         return new task_impl_t(m_func, m_arg);
  48.     }
  49.  
  50. protected:
  51.     task_func_t m_func;
  52.     void*       m_arg;
  53. };
  54.  
  55. struct task_t
  56. {
  57.     static void dumy(void*){}
  58.     task_t(task_func_t f_, void* d_):
  59.         task_impl(new task_impl_t(f_, d_))
  60.     {
  61.     }
  62.     task_t(task_impl_i* task_imp_):
  63.         task_impl(task_imp_)
  64.     {
  65.     }
  66.     task_t(const task_t& src_):
  67.         task_impl(src_.task_impl->fork())
  68.     {
  69.     }
  70.     task_t()
  71.     {
  72.         task_impl = new task_impl_t(&task_t::dumy, NULL);
  73.     }
  74.     ~task_t()
  75.     {
  76.         delete task_impl;
  77.     }
  78.     task_t& operator=(const task_t& src_)
  79.     {
  80.         delete task_impl;
  81.         task_impl = src_.task_impl->fork();
  82.         return *this;
  83.     }
  84.  
  85.     void run()
  86.     {
  87.         task_impl->run();
  88.     }
  89.     task_impl_i*    task_impl;
  90. };
  91.  
  92. class task_queue_i
  93. {
  94. public:
  95.     typedef list<task_t> task_list_t;
  96. public:
  97.     virtual ~task_queue_i(){}
  98.     virtual void close() = 0;
  99.     virtual void produce(const task_t& task_) =0;
  100.     virtual void multi_produce(const task_list_t& task_) =0;
  101.     virtual int  consume(task_t& task_) = 0;
  102.     virtual int  consume_all(task_list_t&) = 0;
  103.     virtual int run() = 0;
  104.     virtual int batch_run() = 0;
  105. };
  106.  
  107. struct task_binder_t
  108. {
  109.     //! C function
  110.  
  111.     static task_t gen(void (*func_)(void*), void* p_)
  112.     {
  113.         return task_t(func_, p_);
  114.     }
  115.     template<typename RET>
  116.     static task_t gen(RET (*func_)(void))
  117.     {
  118.         struct lambda_t
  119.         {
  120.             static void task_func(void* p_)
  121.             {
  122.                 (*(RET(*)(void))p_)();
  123.             };
  124.         };
  125.         return task_t(lambda_t::task_func, (void*)func_);
  126.     }
  127.     template<typename FUNCT, typename ARG1>
  128.     static task_t gen(FUNCT func_, ARG1 arg1_)
  129.     {
  130.         struct lambda_t: public task_impl_i
  131.         {
  132.             FUNCT dest_func;
  133.             ARG1  arg1;
  134.             lambda_t(FUNCT func_, const ARG1& arg1_):
  135.                 dest_func(func_),
  136.                 arg1(arg1_)
  137.             {}
  138.             virtual void run()
  139.             {
  140.                 (*dest_func)(arg1);
  141.             }
  142.             virtual task_impl_i* fork()
  143.             {
  144.                 return new lambda_t(dest_func, arg1);
  145.             }
  146.         };
  147.         return task_t(new lambda_t(func_, arg1_));
  148.     }
  149.     template<typename FUNCT, typename ARG1, typename ARG2>
  150.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_)
  151.     {
  152.         struct lambda_t: public task_impl_i
  153.         {
  154.             FUNCT dest_func;
  155.             ARG1 arg1;
  156.             ARG2 arg2;
  157.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_):
  158.                 dest_func(func_),
  159.                 arg1(arg1_),
  160.                 arg2(arg2_)
  161.             {}
  162.             virtual void run()
  163.             {
  164.                 (*dest_func)(arg1, arg2);
  165.             }
  166.             virtual task_impl_i* fork()
  167.             {
  168.                 return new lambda_t(dest_func, arg1, arg2);
  169.             }
  170.         };
  171.         return task_t(new lambda_t(func_, arg1_, arg2_));
  172.     }
  173.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3>
  174.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
  175.     {
  176.         struct lambda_t:public task_impl_i
  177.         {
  178.             FUNCT dest_func;
  179.             ARG1 arg1;
  180.             ARG2 arg2;
  181.             ARG3 arg3;
  182.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
  183.                 dest_func(func_),
  184.                 arg1(arg1_),
  185.                 arg2(arg2_),
  186.                 arg3(arg3_)
  187.             {}
  188.             virtual void run()
  189.             {
  190.                 (*dest_func)(arg1, arg2, arg3);
  191.             }
  192.             virtual task_impl_i* fork()
  193.             {
  194.                 return new lambda_t(dest_func, arg1, arg2, arg3);
  195.             }
  196.         };
  197.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_));
  198.     }
  199.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4>
  200.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
  201.     {
  202.         struct lambda_t: public task_impl_i
  203.         {
  204.             FUNCT dest_func;
  205.             ARG1 arg1;
  206.             ARG2 arg2;
  207.             ARG3 arg3;
  208.             ARG4 arg4;
  209.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_):
  210.                 dest_func(func_),
  211.                 arg1(arg1_),
  212.                 arg2(arg2_),
  213.                 arg3(arg3_),
  214.                 arg4(arg4_)
  215.             {}
  216.             virtual void run()
  217.             {
  218.                 (*dest_func)(arg1, arg2, arg3, arg4);
  219.             }
  220.             virtual task_impl_i* fork()
  221.             {
  222.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4);
  223.             }
  224.         };
  225.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_));
  226.     }
  227.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
  228.     static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
  229.     {
  230.         struct lambda_t: public task_impl_i
  231.         {
  232.             FUNCT dest_func;
  233.             ARG1 arg1;
  234.             ARG2 arg2;
  235.             ARG3 arg3;
  236.             ARG4 arg4;
  237.             ARG5 arg5;
  238.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  239.                      const ARG5& arg5_):
  240.                 dest_func(func_),
  241.                 arg1(arg1_),
  242.                 arg2(arg2_),
  243.                 arg3(arg3_),
  244.                 arg4(arg4_),
  245.                 arg5(arg5_)
  246.             {}
  247.             virtual void run()
  248.             {
  249.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5);
  250.             }
  251.             virtual task_impl_i* fork()
  252.             {
  253.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5);
  254.             }
  255.         };
  256.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_));
  257.     }
  258.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
  259.     static task_t gen(FUNCT func_,
  260.                        ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  261.                        ARG5 arg5_, ARG6 arg6_)
  262.     {
  263.         struct lambda_t: public task_impl_i
  264.         {
  265.             FUNCT dest_func;
  266.             ARG1 arg1;
  267.             ARG2 arg2;
  268.             ARG3 arg3;
  269.             ARG4 arg4;
  270.             ARG5 arg5;
  271.             ARG6 arg6;
  272.             lambda_t(FUNCT func_,
  273.                      const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  274.                      const ARG5& arg5_, const ARG6& arg6_):
  275.                 dest_func(func_),
  276.                 arg1(arg1_),
  277.                 arg2(arg2_),
  278.                 arg3(arg3_),
  279.                 arg4(arg4_),
  280.                 arg5(arg5_),
  281.                 arg6(arg6_)
  282.             {}
  283.             virtual void run()
  284.             {
  285.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
  286.             }
  287.             virtual task_impl_i* fork()
  288.             {
  289.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6);
  290.             }
  291.         };
  292.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
  293.     }
  294.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
  295.             typename ARG7>
  296.     static task_t gen(FUNCT func_,
  297.                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  298.                       ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
  299.     {
  300.         struct lambda_t: public task_impl_i
  301.         {
  302.             FUNCT dest_func;
  303.             ARG1 arg1;
  304.             ARG2 arg2;
  305.             ARG3 arg3;
  306.             ARG4 arg4;
  307.             ARG5 arg5;
  308.             ARG6 arg6;
  309.             ARG7 arg7;
  310.             lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  311.                      const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
  312.                 dest_func(func_),
  313.                 arg1(arg1_),
  314.                 arg2(arg2_),
  315.                 arg3(arg3_),
  316.                 arg4(arg4_),
  317.                 arg5(arg5_),
  318.                 arg6(arg6_),
  319.                 arg7(arg7_)
  320.             {}
  321.             virtual void run()
  322.             {
  323.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  324.             }
  325.             virtual task_impl_i* fork()
  326.             {
  327.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  328.             }
  329.         };
  330.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
  331.     }
  332.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
  333.             typename ARG7, typename ARG8>
  334.     static task_t gen(FUNCT func_,
  335.                        ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  336.                        ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
  337.     {
  338.         struct lambda_t: public task_impl_i
  339.         {
  340.             FUNCT dest_func;
  341.             ARG1 arg1;
  342.             ARG2 arg2;
  343.             ARG3 arg3;
  344.             ARG4 arg4;
  345.             ARG5 arg5;
  346.             ARG6 arg6;
  347.             ARG7 arg7;
  348.             ARG8 arg8;
  349.             lambda_t(FUNCT func_,
  350.                      const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  351.                      const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
  352.                 dest_func(func_),
  353.                 arg1(arg1_),
  354.                 arg2(arg2_),
  355.                 arg3(arg3_),
  356.                 arg4(arg4_),
  357.                 arg5(arg5_),
  358.                 arg6(arg6_),
  359.                 arg7(arg7_),
  360.                 arg8(arg8_)
  361.             {}
  362.             virtual void run()
  363.             {
  364.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  365.             }
  366.             virtual task_impl_i* fork()
  367.             {
  368.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  369.             }
  370.         };
  371.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
  372.     }
  373.     template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
  374.             typename ARG7, typename ARG8, typename ARG9>
  375.     static task_t gen(FUNCT func_,
  376.                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
  377.                       ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
  378.     {
  379.         struct lambda_t: public task_impl_i
  380.         {
  381.             FUNCT dest_func;
  382.             ARG1 arg1;
  383.             ARG2 arg2;
  384.             ARG3 arg3;
  385.             ARG4 arg4;
  386.             ARG5 arg5;
  387.             ARG6 arg6;
  388.             ARG7 arg7;
  389.             ARG8 arg8;
  390.             ARG9 arg9;
  391.             lambda_t(FUNCT func_,
  392.                      const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  393.                      const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_, const ARG9& arg9_):
  394.                 dest_func(func_),
  395.                 arg1(arg1_),
  396.                 arg2(arg2_),
  397.                 arg3(arg3_),
  398.                 arg4(arg4_),
  399.                 arg5(arg5_),
  400.                 arg6(arg6_),
  401.                 arg7(arg7_),
  402.                 arg8(arg8_),
  403.                 arg9(arg9_)
  404.             {}
  405.             virtual void run()
  406.             {
  407.                 (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  408.             }
  409.             virtual task_impl_i* fork()
  410.             {
  411.                 return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  412.             }
  413.         };
  414.         return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
  415.     }
  416.     //! class fuctions
  417.     template<typename T, typename RET>
  418.     static task_t gen(RET (T::*func_)(void), T* obj_)
  419.     {
  420.         struct lambda_t:public task_impl_i
  421.         {
  422.             RET (T::*dest_func)(void);
  423.             T* obj;
  424.             lambda_t(RET (T::*func_)(void), T* obj_):
  425.                 dest_func(func_),
  426.                 obj(obj_)
  427.             {}
  428.             virtual void run()
  429.             {
  430.                 (obj->*dest_func)();
  431.             }
  432.             virtual task_impl_i* fork()
  433.             {
  434.                 return new lambda_t(dest_func, obj);
  435.             }
  436.         };
  437.         return task_t(new lambda_t(func_, obj_));
  438.     }
  439.     template<typename T, typename RET, typename FARG1, typename ARG1>
  440.     static task_t gen(RET (T::*func_)(FARG1), T* obj_, ARG1 arg1_)
  441.     {
  442.         struct lambda_t: public task_impl_i
  443.         {
  444.             RET (T::*dest_func)(FARG1);
  445.             T* obj;
  446.             ARG1 arg1;
  447.             lambda_t(RET (T::*func_)(FARG1), T* obj_, const ARG1& arg1_):
  448.                 dest_func(func_),
  449.                 obj(obj_),
  450.                 arg1(arg1_)
  451.             {}
  452.             virtual void run()
  453.             {
  454.                 (obj->*dest_func)(arg1);
  455.             }
  456.             virtual task_impl_i* fork()
  457.             {
  458.                 return new lambda_t(dest_func, obj, arg1);
  459.             }
  460.         };
  461.         return task_t(new lambda_t(func_, obj_, arg1_));
  462.     }
  463.     template<typename T, typename RET, typename FARG1, typename FARG2, typename ARG1, typename ARG2>
  464.     static task_t gen(RET (T::*func_)(FARG1, FARG2), T* obj_, ARG1 arg1_, ARG2 arg2_)
  465.     {
  466.         struct lambda_t:public task_impl_i
  467.         {
  468.             RET (T::*dest_func)(FARG1, FARG2);
  469.             T* obj;
  470.             ARG1 arg1;
  471.             ARG2 arg2;
  472.             lambda_t(RET (T::*func_)(FARG1, FARG2), T* obj_, const ARG1& arg1_, const ARG2& arg2_):
  473.                 dest_func(func_),
  474.                 obj(obj_),
  475.                 arg1(arg1_),
  476.                 arg2(arg2_)
  477.             {}
  478.             virtual void run()
  479.             {
  480.                 (obj->*dest_func)(arg1, arg2);
  481.             }
  482.             virtual task_impl_i* fork()
  483.             {
  484.                 return new lambda_t(dest_func, obj, arg1, arg2);
  485.             }
  486.         };
  487.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_));
  488.     }
  489.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename ARG1, typename ARG2,
  490.             typename ARG3>
  491.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
  492.     {
  493.         struct lambda_t:public task_impl_i
  494.         {
  495.             RET (T::*dest_func)(FARG1, FARG2, FARG3);
  496.             T* obj;
  497.             ARG1 arg1;
  498.             ARG2 arg2;
  499.             ARG3 arg3;
  500.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
  501.                 dest_func(func_),
  502.                 obj(obj_),
  503.                 arg1(arg1_),
  504.                 arg2(arg2_),
  505.                 arg3(arg3_)
  506.             {}
  507.             virtual void run()
  508.             {
  509.                 (obj->*dest_func)(arg1, arg2, arg3);
  510.             }
  511.             virtual task_impl_i* fork()
  512.             {
  513.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3);
  514.             }
  515.         };
  516.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_));
  517.     }
  518.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4,
  519.              typename ARG1, typename ARG2, typename ARG3, typename ARG4>
  520.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
  521.     {
  522.         struct lambda_t:public task_impl_i
  523.         {
  524.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4);
  525.             T* obj;
  526.             ARG1 arg1;
  527.             ARG2 arg2;
  528.             ARG3 arg3;
  529.             ARG4 arg4;
  530.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  531.                      const ARG3& arg3_, const ARG4& arg4_):
  532.                 dest_func(func_),
  533.                 obj(obj_),
  534.                 arg1(arg1_),
  535.                 arg2(arg2_),
  536.                 arg3(arg3_),
  537.                 arg4(arg4_)
  538.             {}
  539.             virtual void run()
  540.             {
  541.                 (obj->*dest_func)(arg1, arg2, arg3, arg4);
  542.             }
  543.             virtual task_impl_i* fork()
  544.             {
  545.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4);
  546.             }
  547.         };
  548.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_));
  549.     }
  550.     template<typename T, typename RET,  typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  551.             typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
  552.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, ARG1 arg1_, ARG2 arg2_,  ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
  553.     {
  554.         struct lambda_t: public task_impl_i
  555.         {
  556.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5);
  557.             T* obj;
  558.             ARG1 arg1;
  559.             ARG2 arg2;
  560.             ARG3 arg3;
  561.             ARG4 arg4;
  562.             ARG5 arg5;
  563.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
  564.                      const ARG5& arg5_):
  565.                 dest_func(func_),
  566.                 obj(obj_),
  567.                 arg1(arg1_),
  568.                 arg2(arg2_),
  569.                 arg3(arg3_),
  570.                 arg4(arg4_),
  571.                 arg5(arg5_)
  572.             {}
  573.             virtual void run()
  574.             {
  575.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5);
  576.             }
  577.             virtual task_impl_i* fork()
  578.             {
  579.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5);
  580.             }
  581.         };
  582.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_));
  583.     }
  584.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  585.              typename FARG6, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
  586.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, ARG1 arg1_, ARG2 arg2_,
  587.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_)
  588.     {
  589.         struct lambda_t: public task_impl_i
  590.         {
  591.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6);
  592.             T* obj;
  593.             ARG1 arg1;
  594.             ARG2 arg2;
  595.             ARG3 arg3;
  596.             ARG4 arg4;
  597.             ARG5 arg5;
  598.             ARG6 arg6;
  599.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  600.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_):
  601.                 dest_func(func_),
  602.                 obj(obj_),
  603.                 arg1(arg1_),
  604.                 arg2(arg2_),
  605.                 arg3(arg3_),
  606.                 arg4(arg4_),
  607.                 arg5(arg5_),
  608.                 arg6(arg6_)
  609.             {}
  610.             virtual void run()
  611.             {
  612.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
  613.             }
  614.             virtual task_impl_i* fork()
  615.             {
  616.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6);
  617.             }
  618.         };
  619.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
  620.     }
  621.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  622.              typename FARG6, typename FARG7,
  623.              typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7>
  624.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, ARG1 arg1_, ARG2 arg2_,
  625.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
  626.     {
  627.         struct lambda_t: public task_impl_i
  628.         {
  629.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7);
  630.             T* obj;
  631.             ARG1 arg1;
  632.             ARG2 arg2;
  633.             ARG3 arg3;
  634.             ARG4 arg4;
  635.             ARG5 arg5;
  636.             ARG6 arg6;
  637.             ARG7 arg7;
  638.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  639.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
  640.                 dest_func(func_),
  641.                 obj(obj_),
  642.                 arg1(arg1_),
  643.                 arg2(arg2_),
  644.                 arg3(arg3_),
  645.                 arg4(arg4_),
  646.                 arg5(arg5_),
  647.                 arg6(arg6_),
  648.                 arg7(arg7_)
  649.             {}
  650.             virtual void run()
  651.             {
  652.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  653.             }
  654.             virtual task_impl_i* fork()
  655.             {
  656.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  657.             }
  658.         };
  659.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
  660.     }
  661.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  662.     typename FARG6, typename FARG7, typename FARG8,
  663.     typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7, typename ARG8>
  664.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, ARG1 arg1_, ARG2 arg2_,
  665.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
  666.     {
  667.         struct lambda_t: public task_impl_i
  668.         {
  669.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8);
  670.             T* obj;
  671.             ARG1 arg1;
  672.             ARG2 arg2;
  673.             ARG3 arg3;
  674.             ARG4 arg4;
  675.             ARG5 arg5;
  676.             ARG6 arg6;
  677.             ARG7 arg7;
  678.             ARG8 arg8;
  679.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
  680.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
  681.                 dest_func(func_),
  682.                 obj(obj_),
  683.                 arg1(arg1_),
  684.                 arg2(arg2_),
  685.                 arg3(arg3_),
  686.                 arg4(arg4_),
  687.                 arg5(arg5_),
  688.                 arg6(arg6_),
  689.                 arg7(arg7_),
  690.                 arg8(arg8_)
  691.             {}
  692.             virtual void run()
  693.             {
  694.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  695.             }
  696.             virtual task_impl_i* fork()
  697.             {
  698.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  699.             }
  700.         };
  701.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
  702.     }
  703.     template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
  704.             typename FARG6, typename FARG7, typename FARG8, typename FARG9,
  705.             typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,
  706.             typename ARG8, typename ARG9>
  707.     static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_, ARG1 arg1_, ARG2 arg2_,
  708.                       ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
  709.     {
  710.         struct lambda_t: public task_impl_i
  711.         {
  712.             RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9);
  713.             T* obj;
  714.             ARG1 arg1;
  715.             ARG2 arg2;
  716.             ARG3 arg3;
  717.             ARG4 arg4;
  718.             ARG5 arg5;
  719.             ARG6 arg6;
  720.             ARG7 arg7;
  721.             ARG8 arg8;
  722.             ARG9 arg9;
  723.             lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_,
  724.                      const ARG1& arg1_, const ARG2& arg2_,
  725.                      const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_,
  726.                      const ARG8& arg8_, const ARG9& arg9_):
  727.                 dest_func(func_),
  728.                 obj(obj_),
  729.                 arg1(arg1_),
  730.                 arg2(arg2_),
  731.                 arg3(arg3_),
  732.                 arg4(arg4_),
  733.                 arg5(arg5_),
  734.                 arg6(arg6_),
  735.                 arg7(arg7_),
  736.                 arg8(arg8_),
  737.                 arg9(arg9_)
  738.             {}
  739.             virtual void run()
  740.             {
  741.                 (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  742.             }
  743.             virtual task_impl_i* fork()
  744.             {
  745.                 return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  746.             }
  747.         };
  748.         return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
  749.     }
  750. };
  751.  
  752. }
  753.  
  754. #endif
  755. 	class task_queue_t: public task_queue_i
  756. 	{
  757. 	public:
  758. 		task_queue_t():
  759. 		  m_flag(true),
  760. 			  m_cond(m_mutex)
  761. 		  {
  762. 		  }
  763. 		  ~task_queue_t()
  764. 		  {
  765. 		  }
  766. 		  void close()
  767. 		  {
  768. 			    lock_guard_t lock(m_mutex);
  769. 			    m_flag = false;
  770. 			    m_cond.broadcast();
  771. 		  }
  772.  
  773. 		  void multi_produce(const task_list_t& task_)
  774. 		  {
  775. 			  lock_guard_t lock(m_mutex);
  776. 			  bool need_sig = m_tasklist.empty();
  777.  
  778. 			  for(task_list_t::const_iterator it = task_.begin(); it != task_.end(); ++it)
  779. 			  {
  780. 				  m_tasklist.push_back(*it);
  781. 			  }
  782.  
  783. 			  if (need_sig)
  784. 			  {
  785. 				    m_cond.signal();
  786. 			  }
  787. 		  }
  788. 		  void produce(const task_t& task_)
  789. 		  {
  790. 			  lock_guard_t lock(m_mutex);
  791. 			  bool need_sig = m_tasklist.empty();
  792.  
  793. 			  m_tasklist.push_back(task_);
  794. 			  if (need_sig)
  795. 				      {
  796. 					        m_cond.signal();
  797. 					      }
  798. 		  }
  799.  
  800. 		  int   consume(task_t& task_)
  801. 		  {
  802. 			  lock_guard_t lock(m_mutex);
  803. 			  while (m_tasklist.empty())
  804. 			  {
  805. 				  if (false == m_flag)
  806. 				  {
  807. 					  return -1;
  808. 				  }
  809. 				  m_cond.wait();
  810. 			  }
  811.  
  812. 			  task_ = m_tasklist.front();
  813. 			  m_tasklist.pop_front();
  814.  
  815. 			  return 0;
  816. 		  }
  817.  
  818. 		  int run()
  819. 		  {
  820. 			  task_t t;
  821. 			  while (0 == consume(t))
  822. 			  {
  823. 				  t.run();
  824. 			  }
  825. 			  return 0;
  826. 		  }
  827.  
  828. 		  int consume_all(task_list_t& tasks_)
  829. 		  {
  830. 			  lock_guard_t lock(m_mutex);
  831.  
  832. 			  while (m_tasklist.empty())
  833. 			  {
  834. 				  if (false == m_flag)
  835. 				  {
  836. 					  return -1;
  837. 				  }
  838. 				  m_cond.wait();
  839. 			  }
  840.  
  841. 			  tasks_ = m_tasklist;
  842. 			  m_tasklist.clear();
  843.  
  844. 			  return 0;
  845. 		  }
  846.  
  847. 		  int batch_run()
  848. 			    {
  849. 				    task_list_t tasks;
  850. 				    int ret = consume_all(tasks);
  851. 				      while (0 == ret)
  852. 					      {
  853. 						        for (task_list_t::iterator it = tasks.begin(); it != tasks.end(); ++it)
  854. 							        {
  855. 								          (*it).run();
  856. 								        }
  857. 						        tasks.clear();
  858. 						        ret = consume_all(tasks);
  859. 						      }
  860. 				      return 0;
  861. 				    }
  862. 	private:
  863. 		volatile bool                   m_flag;
  864. 		task_list_t                     m_tasklist;
  865. 		mutex_t                         m_mutex;
  866. 		condition_var_t                 m_cond;
  867. 	};
  868.  
  869. 	class task_queue_pool_t
  870. 	{
  871. 		  typedef task_queue_i::task_list_t task_list_t;
  872. 		typedef vector<task_queue_t*>    task_queue_vt_t;
  873. 		static void task_func(void* pd_)
  874. 		{
  875. 			task_queue_pool_t* t = (task_queue_pool_t*)pd_;
  876. 			t->run();
  877. 		}
  878. 	public:
  879. 		static task_t gen_task(task_queue_pool_t* p)
  880. 		{
  881. 			return task_t(&task_func, p);
  882. 		}
  883. 	public:
  884. 		task_queue_pool_t(int n):
  885. 		    m_index(0)
  886. 		  {
  887. 			  for (int i = 0; i < n; ++i)
  888. 			  {
  889. 				    task_queue_t* p = new task_queue_t();
  890. 				        m_tqs.push_back(p);
  891. 			  }
  892. 		  }
  893.  
  894. 		  void run()
  895. 		  {
  896. 			    task_queue_t* p = NULL;
  897. 			    {
  898. 				        lock_guard_t lock(m_mutex);
  899. 				        if (m_index >= (int)m_tqs.size())
  900. 					        {
  901. 						          throw runtime_error("too more thread running!!");
  902. 						        }
  903. 				          p = m_tqs[m_index++];
  904. 				    }
  905.  
  906. 			    p->batch_run();
  907. 		  }
  908.  
  909. 		  ~task_queue_pool_t()
  910. 		  {
  911. 			  task_queue_vt_t::iterator it = m_tqs.begin();
  912. 			  for (; it != m_tqs.end(); ++it)
  913. 			  {
  914. 				  delete (*it);
  915. 			  }
  916. 			  m_tqs.clear();
  917. 		  }
  918.  
  919. 		  void close()
  920. 		  {
  921. 			  task_queue_vt_t::iterator it = m_tqs.begin();
  922. 			  for (; it != m_tqs.end(); ++it)
  923. 			  {
  924. 				  (*it)->close();
  925. 			  }
  926. 		  }
  927.  
  928. 		  size_t size() const { return m_tqs.size(); }
  929.  
  930. 		  task_queue_i* alloc(long id_)
  931. 		  {
  932. 			    return m_tqs[id_ %  m_tqs.size()];
  933. 		  }
  934. 		  task_queue_i* rand_alloc()
  935. 			    {
  936. 				    static unsigned long id_ = 0;
  937. 				      return m_tqs[++id_ %  m_tqs.size()];
  938. 				    }
  939. 	private:
  940. 		mutex_t               m_mutex;
  941. 		task_queue_vt_t       m_tqs;
  942. 		int            m_index;
  943. 	};
  944.  
  945. }
  946.  
  947. #endif

　　

学习下知然网友写的taskqueue的更多相关文章

  1. TCP/IP详解学习笔记 这位仁兄写得太好了.（转载）

    TCP/IP详解学习笔记   这位仁兄写得太好了   TCP/IP详解学习笔记   这位仁兄写得太好了. http://blog.csdn.net/goodboy1881/category/20444 ...

  2. 前端一面/面试常考题1-页面布局：假设高度已知，请写出三栏布局，其中左栏、右栏宽度各为300px,中间自适应。

    题目:假设高度已知,请写出三栏布局,其中左栏.右栏宽度各为300px,中间自适应. [题外话:日常宣读我的目标===想要成为一名优雅的程序媛] 一.分析 1. 题目真的像我们想得这么简单吗? 其实不然 ...

  3. 一个网友写的栈，问为啥不能迭代。具有__iter__ 和next方法的对象叫迭代器-七七巴巴黄页网

    一个网友写的栈,问为啥不能迭代.具有__iter__ 和next方法的对象叫迭代器-七七巴巴黄页网 一个网友写的栈,问为啥不能迭代.具有__iter__ 和next方法的对象叫迭代器 python视频 ...

  4. 学习下新塘M0芯片的下载方法

    编程方式多种多样,解释这几种方式的原理,方便做后续的回答: 一.脱机 脱机的意思就是脱离PC机,有很多芯片必须连接PC才能烧录,比如某些FPGA芯片.MCU芯片.NAND Flash芯片等.脱机和在线 ...

  5. 深度学习-tensorflow学习笔记(1)-MNIST手写字体识别预备知识

    深度学习-tensorflow学习笔记(1)-MNIST手写字体识别预备知识 在tf第一个例子的时候需要很多预备知识. tf基本知识 香农熵 交叉熵代价函数cross-entropy 卷积神经网络 s ...

  6. 深度学习-tensorflow学习笔记(2)-MNIST手写字体识别

    深度学习-tensorflow学习笔记(2)-MNIST手写字体识别超级详细版 这是tf入门的第一个例子.minst应该是内置的数据集. 前置知识在学习笔记(1)里面讲过了 这里直接上代码 # -*- ...

  7. 学习 Doug Lea 大神写的——Scalable IO in Java

    学习 Doug Lea 大神写的--Scalable IO in Java 网络服务 Web services.分布式对象等等都具有相同的处理结构 Read request Decode reques ...

  8. 算是休息了这么长时间吧！准备学习下python文本处理了，哪位大大有好书推荐的说下！

    算是休息了这么长时间吧!准备学习下python文本处理了,哪位大大有好书推荐的说下!

  9. 在windows下用C语言写socket通讯实例

    原文:在windows下用C语言写socket通讯实例 From:Microsoft Dev Center #undef UNICODE #define WIN32_LEAN_AND_MEAN #in ...

随机推荐

  1. buntu14.04和16.04官方默认更新源sources.list和第三方源推荐（干货！）转

    配置完成后: sudo apt-get update 安装和删除软件: sudo apt-get install sudo apt-get remove buntu14.04和16.04官方默认更新源 ...

  2. Asp.Net Core 2.0 项目实战（3）NCMVC角色权限管理前端UI预览及下载

    Asp.Net Core 2.0 项目实战(1) NCMVC开源下载了 Asp.Net Core 2.0 项目实战(2)NCMVC一个基于Net Core2.0搭建的角色权限管理开发框架 Asp.Ne ...

  3. NDK官方下载链接

    注:本文转载于成江海:<Android各个版本的NDK官方下载链接 > NDK官方网站:https://developer.android.google.cn/ndk/downloads/ ...

  4. Coredata 单表简单使用

    ** 使用Coredata 工程中的DataModel创建:系统创建.手动创建** ** 使用Coredata需要要导入<CoreData/CoreData.h> ** 1.系统创建(系统 ...

  5. js基础梳理-究竟什么是执行上下文栈（执行栈），执行上下文(可执行代码）？

    日常在群里讨论一些概念性的问题,比如变量提升,作用域和闭包相关问题的时候,经常会听一些大佬们给别人解释的时候说执行上下文,调用上下文巴拉巴拉,总有点似懂非懂,不明觉厉的感觉.今天,就对这两个概念梳理一 ...

  6. 【原创】ABP源码分析

    接口篇 IConventionalDependencyRegistra接口分析 待续.............. 模块篇 敬请期待...... 领域篇 敬请期待...... 消息篇 敬请期待..... ...

  7. webpack的版本进化史

    一.概述2015,webpack1支持CMD和AMD,同时拥有丰富的plugin和loader,webpack逐渐得到广泛应用. 2016.12,webpack2相对于webpack1最大的改进就是支 ...

  8. 潭州课堂25班：Ph201805201 第十六课 正则 (课堂笔记)

    import re 元字符: . ^ $ * + ? {} \ () # s = 'abcdefg' # s.find('c') # print(s.find('cd')) ## 查找 # b = s ...

  9. 初试Django的缓存系统

    初试Django的缓存系统 现在我网页的逻辑是,响应请求,查找数据库相关信息,渲染模版生成最终页面,最后返回.使用缓存后就是将这个页面保存一段时间,在有响应请求相同页面的时候,可以直接返回,不用再做那 ...

  10. 正则表达式(特殊字符)/Xpath语法/CSS选择器

    正则表达式(特殊字符) ^ 开头 '^b.*'----以b开头的任意字符 $ 结尾 '^b.*3$'----以b开头,3结尾的任意字符 * 任意长度(次数),≥0 ? 非贪婪模式,非贪婪模式尽可能少的 ...