std::function 与Queue配合起来

有的时候对于一些操作会排队，搞个队列，把请求丢到队列里面去，然后一个一个取出来，去执行。如果这些操作可以并发，就可以用多个线程去取队列里面的数据，典型的生产者消费者。

了解了一点C++11，发现function 和容器结合起来，一个可重用的异步task就来了。

template<typename F>
class TaskQueue
{
public:
    TaskQueue() {};
    ~TaskQueue() {};

    void Register(std::function<F>&& fun) {
        taskStack.push(fun);
    }
    std::function<F> Take()
    {
        if (!taskStack.empty())
        {
            auto elem = taskStack.top();
            taskStack.pop();
            return elem;
        }
        return nullptr;
    }
private:
    std::stack<std::function<F>> taskStack;
};

这里用模版，这样就根据函数的签名，定义各种各样的Queu就简单多了，这里只是演示，一般还需要一个线程，或者线程池来取里面的数据，利用条件变量来同步。这里只是简单的演示下，如何去适配函数对象，函数指针，以及成员函数。

定义几个业务函数，和print

void print(int x)
{
    std::cout << "invoke " << __FUNCTION__ << std::endl;
}

void print1(int x)
{
    std::cout << "invoke " << __FUNCTION__ << std::endl;
}
void print2(int x)
{
    std::cout << "invoke " << __FUNCTION__ << std::endl;
}
void print3(int x)
{
    std::cout << "invoke " << __FUNCTION__ << std::endl;
}

struct business_fun_1
{
    void operator()(int parameter) {
        std::cout << "invoke " << __FUNCTION__ << std::endl;
    }
};

struct business_fun_2
{
    void handler(int x) {
        std::cout << "invoke " << __FUNCTION__ << std::endl;
    }
};

然后往里面插就行了

    int x = 10;
    TaskQueue<void(int)> taskQueue;
    taskQueue.Register(print);
    taskQueue.Register(print1);
    taskQueue.Register(print2);    
    business_fun_1 obj;
    taskQueue.Register(obj);
    business_fun_2 obj2;
    auto f = std::bind(&business_fun_2::handler, &obj2, std::placeholders::_1);
    taskQueue.Register(f);

然后取出来，一个一个执行

{
        auto f = taskQueue.Take();
        if (f != nullptr) f(x);
    }
    {
        auto f = taskQueue.Take();
        if (f != nullptr) f(x);
    }
    {
        auto f = taskQueue.Take();
        if (f != nullptr) f(x);
    }
    {
        auto f = taskQueue.Take();
        if (f != nullptr) f(x);
    }
    {
        auto f = taskQueue.Take();
        if (f != nullptr) f(x);
    }

这样就近乎拥有了一个异步的task

备注：再写一个threadpool的配合可变参数，是不是就是一个完美的task 高度可定制化复用类了。