学习下知然网友写的taskqueue

最新推荐文章于 2024-12-14 23:23:53 发布
转载 最新推荐文章于 2024-12-14 23:23:53 发布 · 85 阅读 · 0

本文详细介绍了任务队列的设计与实现，包括任务队列接口定义、任务生成器和任务执行流程，旨在提高并发任务处理效率。

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

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

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

#ifndef _TASK_QUEUE_I_
#define _TASK_QUEUE_I_

#include <list>
#include <vector>
using namespace std;

namespace ff {

typedef void (*task_func_t)(void*);

class task_impl_i
{
public:
    virtual ~task_impl_i(){}
    virtual void run()          = 0;
    virtual task_impl_i* fork() = 0;
};

class task_impl_t: public task_impl_i
{
public:
    task_impl_t(task_func_t func_, void* arg_):
        m_func(func_),
        m_arg(arg_)
    {}

    virtual void run()
    {
        m_func(m_arg);
    }

    virtual task_impl_i* fork()
    {
        return new task_impl_t(m_func, m_arg);
    }

protected:
    task_func_t m_func;
    void*       m_arg;
};

struct task_t
{
    static void dumy(void*){}
    task_t(task_func_t f_, void* d_):
        task_impl(new task_impl_t(f_, d_))
    {
    }
    task_t(task_impl_i* task_imp_):
        task_impl(task_imp_)
    {
    }
    task_t(const task_t& src_):
        task_impl(src_.task_impl->fork())
    {
    }
    task_t()
    {
        task_impl = new task_impl_t(&task_t::dumy, NULL);
    }
    ~task_t()
    {
        delete task_impl;
    }
    task_t& operator=(const task_t& src_)
    {
        delete task_impl;
        task_impl = src_.task_impl->fork();
        return *this;
    }
    
    void run()
    {
        task_impl->run();
    }
    task_impl_i*    task_impl;
};

class task_queue_i
{
public:
    typedef list<task_t> task_list_t;
public:
    virtual ~task_queue_i(){}
    virtual void close() = 0;
    virtual void produce(const task_t& task_) =0;
    virtual void multi_produce(const task_list_t& task_) =0;
    virtual int  consume(task_t& task_) = 0;
    virtual int  consume_all(task_list_t&) = 0;
    virtual int run() = 0;
    virtual int batch_run() = 0;
};

struct task_binder_t
{
    //! C function
    
    static task_t gen(void (*func_)(void*), void* p_)
    {
        return task_t(func_, p_);
    }
    template<typename RET>
    static task_t gen(RET (*func_)(void))
    {
        struct lambda_t
        {
            static void task_func(void* p_)
            {
                (*(RET(*)(void))p_)();
            };
        };
        return task_t(lambda_t::task_func, (void*)func_);
    }
    template<typename FUNCT, typename ARG1>
    static task_t gen(FUNCT func_, ARG1 arg1_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1  arg1;
            lambda_t(FUNCT func_, const ARG1& arg1_):
                dest_func(func_),
                arg1(arg1_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1);
            }
        };
        return task_t(new lambda_t(func_, arg1_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
    {
        struct lambda_t:public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
    static task_t gen(FUNCT func_,
                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                       ARG5 arg5_, ARG6 arg6_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            lambda_t(FUNCT func_,
                     const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
            typename ARG7>
    static task_t gen(FUNCT func_,
                      ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                      ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
            typename ARG7, typename ARG8>
    static task_t gen(FUNCT func_,
                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                       ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            lambda_t(FUNCT func_,
                     const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
            typename ARG7, typename ARG8, typename ARG9>
    static task_t gen(FUNCT func_,
                      ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                      ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            ARG9 arg9;
            lambda_t(FUNCT func_,
                     const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_, const ARG9& arg9_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_),
                arg9(arg9_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
    }
    //! class fuctions
    template<typename T, typename RET>
    static task_t gen(RET (T::*func_)(void), T* obj_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(void);
            T* obj;
            lambda_t(RET (T::*func_)(void), T* obj_):
                dest_func(func_),
                obj(obj_)
            {}
            virtual void run()
            {
                (obj->*dest_func)();
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj);
            }
        };
        return task_t(new lambda_t(func_, obj_));
    }
    template<typename T, typename RET, typename FARG1, typename ARG1>
    static task_t gen(RET (T::*func_)(FARG1), T* obj_, ARG1 arg1_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1);
            T* obj;
            ARG1 arg1;
            lambda_t(RET (T::*func_)(FARG1), T* obj_, const ARG1& arg1_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename ARG1, typename ARG2>
    static task_t gen(RET (T::*func_)(FARG1, FARG2), T* obj_, ARG1 arg1_, ARG2 arg2_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            lambda_t(RET (T::*func_)(FARG1, FARG2), T* obj_, const ARG1& arg1_, const ARG2& arg2_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename ARG1, typename ARG2,
            typename ARG3>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4,
             typename ARG1, typename ARG2, typename ARG3, typename ARG4>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_));
    }
    template<typename T, typename RET,  typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
            typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, ARG1 arg1_, ARG2 arg2_,  ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
             typename FARG6, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
             typename FARG6, typename FARG7,
             typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
    typename FARG6, typename FARG7, typename FARG8,
    typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7, typename ARG8>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
            typename FARG6, typename FARG7, typename FARG8, typename FARG9,
            typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,
            typename ARG8, typename ARG9>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            ARG9 arg9;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_,
                     const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_,
                     const ARG8& arg8_, const ARG9& arg9_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_),
                arg9(arg9_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
    }
};

}

#endif

　　

#ifndef _TASK_QUEUE_IMPL_H_
#define _TASK_QUEUE_IMPL_H_

#include<pthread.h>
#include <list>
#include <stdexcept>
using namespace std;

#include "task_queue_i.h"
#include "lock.h"

namespace ff {
#ifndef _TASK_QUEUE_I_
#define _TASK_QUEUE_I_

#include <list>
#include <vector>
using namespace std;

namespace ff {

typedef void (*task_func_t)(void*);

class task_impl_i
{
public:
    virtual ~task_impl_i(){}
    virtual void run()          = 0;
    virtual task_impl_i* fork() = 0;
};

class task_impl_t: public task_impl_i
{
public:
    task_impl_t(task_func_t func_, void* arg_):
        m_func(func_),
        m_arg(arg_)
    {}

    virtual void run()
    {
        m_func(m_arg);
    }

    virtual task_impl_i* fork()
    {
        return new task_impl_t(m_func, m_arg);
    }

protected:
    task_func_t m_func;
    void*       m_arg;
};

struct task_t
{
    static void dumy(void*){}
    task_t(task_func_t f_, void* d_):
        task_impl(new task_impl_t(f_, d_))
    {
    }
    task_t(task_impl_i* task_imp_):
        task_impl(task_imp_)
    {
    }
    task_t(const task_t& src_):
        task_impl(src_.task_impl->fork())
    {
    }
    task_t()
    {
        task_impl = new task_impl_t(&task_t::dumy, NULL);
    }
    ~task_t()
    {
        delete task_impl;
    }
    task_t& operator=(const task_t& src_)
    {
        delete task_impl;
        task_impl = src_.task_impl->fork();
        return *this;
    }
    
    void run()
    {
        task_impl->run();
    }
    task_impl_i*    task_impl;
};

class task_queue_i
{
public:
    typedef list<task_t> task_list_t;
public:
    virtual ~task_queue_i(){}
    virtual void close() = 0;
    virtual void produce(const task_t& task_) =0;
    virtual void multi_produce(const task_list_t& task_) =0;
    virtual int  consume(task_t& task_) = 0;
    virtual int  consume_all(task_list_t&) = 0;
    virtual int run() = 0;
    virtual int batch_run() = 0;
};

struct task_binder_t
{
    //! C function
    
    static task_t gen(void (*func_)(void*), void* p_)
    {
        return task_t(func_, p_);
    }
    template<typename RET>
    static task_t gen(RET (*func_)(void))
    {
        struct lambda_t
        {
            static void task_func(void* p_)
            {
                (*(RET(*)(void))p_)();
            };
        };
        return task_t(lambda_t::task_func, (void*)func_);
    }
    template<typename FUNCT, typename ARG1>
    static task_t gen(FUNCT func_, ARG1 arg1_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1  arg1;
            lambda_t(FUNCT func_, const ARG1& arg1_):
                dest_func(func_),
                arg1(arg1_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1);
            }
        };
        return task_t(new lambda_t(func_, arg1_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
    {
        struct lambda_t:public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
    static task_t gen(FUNCT func_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
    static task_t gen(FUNCT func_,
                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                       ARG5 arg5_, ARG6 arg6_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            lambda_t(FUNCT func_,
                     const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
            typename ARG7>
    static task_t gen(FUNCT func_,
                      ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                      ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            lambda_t(FUNCT func_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
            typename ARG7, typename ARG8>
    static task_t gen(FUNCT func_,
                       ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                       ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            lambda_t(FUNCT func_,
                     const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
    }
    template<typename FUNCT, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6,
            typename ARG7, typename ARG8, typename ARG9>
    static task_t gen(FUNCT func_,
                      ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_,
                      ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
    {
        struct lambda_t: public task_impl_i
        {
            FUNCT dest_func;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            ARG9 arg9;
            lambda_t(FUNCT func_,
                     const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_, const ARG9& arg9_):
                dest_func(func_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_),
                arg9(arg9_)
            {}
            virtual void run()
            {
                (*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
        };
        return task_t(new lambda_t(func_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
    }
    //! class fuctions
    template<typename T, typename RET>
    static task_t gen(RET (T::*func_)(void), T* obj_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(void);
            T* obj;
            lambda_t(RET (T::*func_)(void), T* obj_):
                dest_func(func_),
                obj(obj_)
            {}
            virtual void run()
            {
                (obj->*dest_func)();
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj);
            }
        };
        return task_t(new lambda_t(func_, obj_));
    }
    template<typename T, typename RET, typename FARG1, typename ARG1>
    static task_t gen(RET (T::*func_)(FARG1), T* obj_, ARG1 arg1_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1);
            T* obj;
            ARG1 arg1;
            lambda_t(RET (T::*func_)(FARG1), T* obj_, const ARG1& arg1_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename ARG1, typename ARG2>
    static task_t gen(RET (T::*func_)(FARG1, FARG2), T* obj_, ARG1 arg1_, ARG2 arg2_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            lambda_t(RET (T::*func_)(FARG1, FARG2), T* obj_, const ARG1& arg1_, const ARG2& arg2_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename ARG1, typename ARG2,
            typename ARG3>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4,
             typename ARG1, typename ARG2, typename ARG3, typename ARG4>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, ARG1 arg1_, ARG2 arg2_, ARG3 arg3_, ARG4 arg4_)
    {
        struct lambda_t:public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_));
    }
    template<typename T, typename RET,  typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
            typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, ARG1 arg1_, ARG2 arg2_,  ARG3 arg3_, ARG4 arg4_, ARG5 arg5_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5), T* obj_, const ARG1& arg1_, const ARG2& arg2_, const ARG3& arg3_, const ARG4& arg4_,
                     const ARG5& arg5_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
             typename FARG6, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
             typename FARG6, typename FARG7,
             typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
    typename FARG6, typename FARG7, typename FARG8,
    typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7, typename ARG8>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8), T* obj_, const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_, const ARG8& arg8_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_));
    }
    template<typename T, typename RET, typename FARG1, typename FARG2, typename FARG3, typename FARG4, typename FARG5,
            typename FARG6, typename FARG7, typename FARG8, typename FARG9,
            typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,
            typename ARG8, typename ARG9>
    static task_t gen(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_, ARG1 arg1_, ARG2 arg2_,
                      ARG3 arg3_, ARG4 arg4_, ARG5 arg5_, ARG6 arg6_, ARG7 arg7_, ARG8 arg8_, ARG9 arg9_)
    {
        struct lambda_t: public task_impl_i
        {
            RET (T::*dest_func)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9);
            T* obj;
            ARG1 arg1;
            ARG2 arg2;
            ARG3 arg3;
            ARG4 arg4;
            ARG5 arg5;
            ARG6 arg6;
            ARG7 arg7;
            ARG8 arg8;
            ARG9 arg9;
            lambda_t(RET (T::*func_)(FARG1, FARG2, FARG3, FARG4, FARG5, FARG6, FARG7, FARG8, FARG9), T* obj_,
                     const ARG1& arg1_, const ARG2& arg2_,
                     const ARG3& arg3_, const ARG4& arg4_, const ARG5& arg5_, const ARG6& arg6_, const ARG7& arg7_,
                     const ARG8& arg8_, const ARG9& arg9_):
                dest_func(func_),
                obj(obj_),
                arg1(arg1_),
                arg2(arg2_),
                arg3(arg3_),
                arg4(arg4_),
                arg5(arg5_),
                arg6(arg6_),
                arg7(arg7_),
                arg8(arg8_),
                arg9(arg9_)
            {}
            virtual void run()
            {
                (obj->*dest_func)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
            virtual task_impl_i* fork()
            {
                return new lambda_t(dest_func, obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
            }
        };
        return task_t(new lambda_t(func_, obj_, arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_));
    }
};

}

#endif
	class task_queue_t: public task_queue_i
	{
	public:
		task_queue_t():
		  m_flag(true),
			  m_cond(m_mutex)
		  {
		  }
		  ~task_queue_t()
		  {
		  }
		  void close()
		  {
			    lock_guard_t lock(m_mutex);
			    m_flag = false;
			    m_cond.broadcast();
		  }

		  void multi_produce(const task_list_t& task_)
		  {
			  lock_guard_t lock(m_mutex);
			  bool need_sig = m_tasklist.empty();

			  for(task_list_t::const_iterator it = task_.begin(); it != task_.end(); ++it)
			  {
				  m_tasklist.push_back(*it);
			  }

			  if (need_sig)
			  {
				    m_cond.signal();
			  }
		  }
		  void produce(const task_t& task_)
		  {        
			  lock_guard_t lock(m_mutex);
			  bool need_sig = m_tasklist.empty();

			  m_tasklist.push_back(task_);
			  if (need_sig)
				      {
					        m_cond.signal();
					      }
		  }

		  int   consume(task_t& task_)
		  {
			  lock_guard_t lock(m_mutex);
			  while (m_tasklist.empty())
			  {
				  if (false == m_flag)
				  {
					  return -1;
				  }
				  m_cond.wait();
			  }

			  task_ = m_tasklist.front();
			  m_tasklist.pop_front();

			  return 0;
		  }

		  int run()
		  {
			  task_t t;
			  while (0 == consume(t))
			  {
				  t.run();
			  }
			  return 0;
		  }

		  int consume_all(task_list_t& tasks_)
		  {
			  lock_guard_t lock(m_mutex);

			  while (m_tasklist.empty())
			  {
				  if (false == m_flag)
				  {
					  return -1;
				  }
				  m_cond.wait();
			  }

			  tasks_ = m_tasklist;
			  m_tasklist.clear();

			  return 0;
		  }

		  int batch_run()
			    {
				    task_list_t tasks;
				    int ret = consume_all(tasks);
				      while (0 == ret)
					      {
						        for (task_list_t::iterator it = tasks.begin(); it != tasks.end(); ++it)
							        {
								          (*it).run();
								        }
						        tasks.clear();
						        ret = consume_all(tasks);
						      }
				      return 0;
				    }
	private:
		volatile bool                   m_flag;
		task_list_t                     m_tasklist;
		mutex_t                         m_mutex;
		condition_var_t                 m_cond;
	};

	class task_queue_pool_t
	{
		  typedef task_queue_i::task_list_t task_list_t;
		typedef vector<task_queue_t*>    task_queue_vt_t;
		static void task_func(void* pd_)
		{
			task_queue_pool_t* t = (task_queue_pool_t*)pd_;
			t->run();
		}
	public:
		static task_t gen_task(task_queue_pool_t* p)
		{
			return task_t(&task_func, p);
		}
	public:
		task_queue_pool_t(int n):
		    m_index(0)
		  {
			  for (int i = 0; i < n; ++i)
			  {
				    task_queue_t* p = new task_queue_t();
				        m_tqs.push_back(p);
			  }
		  }

		  void run()
		  {
			    task_queue_t* p = NULL;
			    {
				        lock_guard_t lock(m_mutex);
				        if (m_index >= (int)m_tqs.size())
					        {
						          throw runtime_error("too more thread running!!");
						        }
				          p = m_tqs[m_index++];
				    }

			    p->batch_run();
		  }

		  ~task_queue_pool_t()
		  {
			  task_queue_vt_t::iterator it = m_tqs.begin();
			  for (; it != m_tqs.end(); ++it)
			  {
				  delete (*it);
			  }
			  m_tqs.clear();
		  }

		  void close()
		  {
			  task_queue_vt_t::iterator it = m_tqs.begin();
			  for (; it != m_tqs.end(); ++it)
			  {
				  (*it)->close();
			  }
		  }

		  size_t size() const { return m_tqs.size(); }

		  task_queue_i* alloc(long id_)
		  {
			    return m_tqs[id_ %  m_tqs.size()];
		  }
		  task_queue_i* rand_alloc()
			    {
				    static unsigned long id_ = 0;
				      return m_tqs[++id_ %  m_tqs.size()];
				    }
	private:
		mutex_t               m_mutex;
		task_queue_vt_t       m_tqs;
		int            m_index;
	};

}

#endif

　　

多态性
知然的专栏
09-09 1388
面向对象程序设计中的多态性： 多态性(polymorphism)是面向对象编程的基本特征之一。在ｃ＋＋中指具有不同功能的函数可以用同一个函数名，即可以用同一个函数名调用不同内容的函数。向不同对象发送同一个消息，不同的对象在接收同一消息时会产生不同的行为（方法）。 　　从系统实现角度来看，多态性分为两类：静态多态性和动态多态性。 　　静态多态性：在程序编译时系统就能决定调用哪个函数，因此静态函
【学习笔记】手写 Tomcat 六
LearnTech_123的博客
09-26 1623
昨天使用了数据库连接池，我们了解了连接池的优点，那么也可以使用线程池来管理线程，java自带的线程池的参数有 核心线程数，最大线程数，线程活跃时间，时间单位，任务队列，线程工厂，拒绝策略。为了学习了解线程池，我们先手写一个简单的线程池，只需要做到核心线程可重复利用就行。
1 TaskQueue 实现Task 队列
weixin_30699443的博客
12-22 1094
class Program { static void Main(string[] args) { List<Person> list = new List<Person>(); for (int i = 0; i < 10; i++) ...
知然的代码
weixin_34335458的博客
01-28 84
贴下来学习，转自http://www.cnblogs.com/zhiranok/archive/2012/05/13/cpp_multi_thread.html #ifndef _TASK_QUEUE_IMPL_H_ #define _TASK_QUEUE_IMPL_H_ #include&lt;pthread.h&gt; #include &lt;list&gt; #inclu...
Netty 的 TaskQueue 学习
xl-9527 的博客
09-17 279
简介把花费时间比较长的任务提交到 NioEventLoopGroup 的 TaskQueue 中进行异步执行。
webrtc 的TaskQueue() 任务队列
lcalqf的专栏
07-31 1005
webrtc 任务队列 TaskQueue
学习记录(4.4)---面向对象TaskQueue任务队列类的封装
Lllpppyyyl的博客
05-04 330
我们已经介绍了MutexLock(互斥锁)类和Condition(条件变量）类的封装，现在我们组合在一起封装存取任务的仓库TaskQueue。
Netty学习（四）：TaskQueue中Task的三种典型使用场景
m0_49499183的博客
03-06 244
在前文Netty学习（三）：Netty线程模型和代码示例中我们学习了netty的线程模型。其中，NIOEventLoop中有两个很重要的部分，一个是Selector，一个是TaskQueue。今天我们要来介绍TaskQueue。我们知道，Pipeline中的一些重量级任务，会放入TaskQueue中异步处理，那么TaskQueue是如何处理这些Task的呢？@Override//比如这里我们有一个非常耗时长的业务-> 异步执行 -> 提交该channel 对应的。
taskqueue java_2.并发容器-TaskQueue
weixin_39712724的博客
02-16 297
TaskQueue再来看看队列 public class TaskQueue extends LinkedBlockingQueue {}Queue* @since 1.5* @author Doug Lea//还继承了Collection体系public interface Queue extends Collection {//增加一个元索 如果队列已满...
使用任务队列TaskQueue和线程池ThreadPool技术实现自定义定时任务框架详解
dotnet研习社
12-14 1548
在桌面软件开发中，定时任务是一个常见的需求，比如定时清理日志、发送提醒邮件或执行数据备份等操作。在C#中有一个非常著名的定时任务处理库Hangfire，不过在我们深入了解Hangfire 之前，我们可以手动开发一个定时任务案例，用以帮助我们理解Hangfire的核心原理。我们可以利用 任务队列（Task Queue） 和 线程池（Thread Pool） 这两个核心概念，构建一个高效且具有良好扩展性的定时任务系统。本文将从零开始实现一个基于任务队列和线程池的定时任务框架，并结合实际应用场景进行详细解析。首先
ws-taskqueue-server:Websocket服务器通信
05-24
git clone https://github.com/burmisov/ws-taskqueue-server npm install npm start 服务器正在侦听端口8080或$PORT指定的$PORT 如果设置$DEBUG = "wstq:*" ，则可以在控制台中看到扩展的调试输出。 仪表盘 在...
taskqueue:使用线程池并行完成任务的任务队列
07-13
TaskQueue 是一个只有头文件的库，用于与使用 Boost 构建的并行执行任务。 如何使用它 要使用它，您需要做的就是将复制到您的源代码树并链接到 Boost 线程和 asio 库。 没有文档，只有一个工作示例，用于计算使用...
taskqueue-website:TaskQueue的网站
05-17
TaskQueue网站 此回购中包含网站，文档和博客。 入门 即将推出... 古尔普 我们使用的是gulp 4.0的预发布版本，因此请按照以下步骤设置本地计算机： 1.全局安装gulp： $ npm install --global gulpjs/gulp.git#4.0 2...
基于VMD-Attention-LSTM的时间序列预测模型（代码仅使用了一个较小数据集的训练及预测，内含使用使用逻辑，适合初学者观看，模型结构是可行的，有能力的请尝试使用更大的数据集训练）
08-23
资源下载链接为： https://pan.quark.cn/s/f4901605d35f (最新版、最全版本)基于VMD-Attention-LSTM的时间序列预测模型（代码仅使用了一个较小数据集的训练及预测，内含使用使用逻辑，适合初学者观看，模型结构是可行的，有能力的请尝试使用更大的数据集训练）
MATLABSimulink扩频通信系统仿真：BPSKQPSK调制与WalshmGold序列的误码率分析及GUI设计
08-23
基于MATLAB/Simulink平台的扩频通信系统仿真研究。主要内容包括构建扩频通信系统的仿真模型，应用BPSK和QPSK调制技术，使用Walsh、m序列和Gold序列进行扩频处理，生成并分析信号波形图，计算误码率，并设计了用户友好的GUI界面。通过这些步骤，研究人员可以深入了解扩频通信系统的性能特点及其抗干扰能力。 适合人群：从事通信工程领域的科研人员和技术开发者，尤其是对扩频通信技术和MATLAB/Simulink有初步了解的人群。 使用场景及目标：①用于教学和培训，帮助学生掌握扩频通信系统的理论知识和实际操作技能；②为科研项目提供技术支持，验证不同调制方式和扩频码对系统性能的影响；③辅助产品开发，优化通信设备的设计。 其他说明：文中提供了详细的建模方法和具体的实现步骤，附带m源代码，便于读者理解和复现实验结果。
Day09_随堂笔记.pdf
08-23
Python进阶
MATLAB中深度神经网络多特征输入单输出分类模型的实现与可视化
08-23
内容概要：本文档详细介绍了如何在MATLAB中实现深度神经网络（DNN）的多特征输入单输出分类模型，涵盖二分类和多分类任务。文档提供了详细的代码注释，指导用户从数据导入、预处理到模型构建、训练以及最终的预测和效果评估全过程。此外，还展示了如何利用MATLAB内置函数生成分类效果图、迭代优化图和混淆矩阵图，帮助用户直观地理解和评估模型性能。 适合人群：具有一定MATLAB编程基础的研究人员和技术爱好者，尤其是那些希望深入了解深度学习及其应用的人群。 使用场景及目标：适用于需要解决多特征输入分类问题的研究项目或工业应用场景。通过学习本文档，用户能够掌握如何快速搭建和调优DNN模型，从而提高分类任务的准确性。 阅读建议：建议读者先熟悉MATLAB的基本语法和深度学习工具箱的功能，再逐步跟随文档中的步骤进行实践。同时，鼓励读者尝试不同的数据集和参数配置，探索最佳模型表现。
电力市场中基于价值认同的电能共享分布式交易策略研究 价值认同
08-23
内容概要：本文围绕电能共享市场的交易机制展开分析，提出了基于价值认同的需求侧电能共享分布式交易策略。文章首先介绍了电能共享市场的背景及其重要性，接着详细阐述了价值认同机制的设计，通过建立用户满意度和服务质量评估体系，减少无序竞争带来的无谓损失。此外，文章还设计了一致性算法支持的分布式交易策略，实现了产消者间的去中心化交易，提高了交易透明度和效率，保护了用户隐私。最后，基于剩余理论，文章探讨了边际价格驱动下的电能共享模式，并通过市场博弈模型揭示了无序竞争的问题。 适合人群：从事电力市场研究的专业人士、能源政策制定者以及对电能共享市场感兴趣的学者和技术专家。 使用场景及目标：适用于希望深入了解电能共享市场运作机制的人群，特别是那些致力于优化电力市场交易机制、降低成本、提高市场效率的研究者和从业者。 其他说明：本文不仅提供了理论分析，还提出了具体的技术解决方案，有助于推动电能共享市场的创新发展。
【医学影像处理】基于跨模态核磁共振图像超分辨率的T2WI重建：融合T1WI辅助信息的高效网络设计与量化部署（论文复现含详细代码及解释）
最新发布
08-23
内容概要：该论文聚焦于T2WI核磁共振图像超分辨率问题，提出了一种利用T1WI模态作为辅助信息的跨模态解决方案。其主要贡献包括：提出基于高频信息约束的网络框架，通过主干特征提取分支和高频结构先验建模分支结合Transformer模块和注意力机制有效重建高频细节；设计渐进式特征匹配融合框架，采用多阶段相似特征匹配算法提高匹配鲁棒性；引入模型量化技术降低推理资源需求。实验结果表明，该方法不仅提高了超分辨率性能，还保持了图像质量。 适合人群：从事医学图像处理、计算机视觉领域的研究人员和工程师，尤其是对核磁共振图像超分辨率感兴趣的学者和技术开发者。 使用场景及目标：①适用于需要提升T2WI核磁共振图像分辨率的应用场景；②目标是通过跨模态信息融合提高图像质量，解决传统单模态方法难以克服的高频细节丢失问题；③为临床诊断提供更高质量的影像资料，帮助医生更准确地识别病灶。 其他说明：论文不仅提供了详细的网络架构设计与实现代码，还深入探讨了跨模态噪声的本质、高频信息约束的实现方式以及渐进式特征匹配的具体过程。此外，作者还对模型进行了量化处理，使得该方法可以在资源受限环境下高效运行。阅读时应重点关注论文中提到的技术创新点及其背后的原理，理解如何通过跨模态信息融合提升图像重建效果。
TaskQueue DEMO演示：多线程任务分配实践
在讨论与“TaskQueue的DEMO SHOW”相关的知识点之前，首先要理解什么是TaskQueue，以及它在多线程环境中的作用。...它可能包含了多种任务分配的场景和策略，帮助开发者理解和学习如何在实际应用中使用TaskQueue。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值