c++ - lambda 队列是 C++11 中工作队列的良好设计模式吗？

Question

我必须制作一个线程安全的工作队列，它可以在不同的线程中弹出工作，并将在工作线程上处理它。这项工作可能非常通用，所以我在考虑使用带有捕获的 lambdas 作为实现这一点的好方法。我有以下代码作为入门:

#include <iostream>
#include <vector>
#include <functional> 
typedef std::function<void()> Task;
typedef std::vector<Task> TaskQueue;

class Queue 
{
   public:
    void flush() {
        for (auto it : m_queue) {
            it();
        }
    }
   // will add thread safe locks later.        
    void queue(Task task) {
        m_queue.push_back(task);
    }

private:
    TaskQueue m_queue;
};
Queue q;

class WorkMaker
{
public: 

    WorkMaker(int inA) : m_a(inA) {}

    void MakeWork() {
        q.queue([&]{
            std::cout << this->m_a << std::endl;
        });
    }


private:
    int m_a;
};

int main()
{
  WorkMaker w1(1);
  WorkMaker w2(2);
  w1.MakeWork();
  w2.MakeWork();
  q.flush();
  return 0;
}

这段代码是否存在固有的性能问题，或者编译器会优化它吗？还通过值复制 lambda 或只是指向它的指针将 lambda 传递到 std::function 参数吗？

编辑:

我想我可以通过使用 shared_ptr 并将它们传递给 lambda 来解决内存所有权问题。考虑以下修改:

typedef std::function<void()> Task;
typedef std::deque<Task> TaskQueue;

class Queue 
{
   public:
    void flush() {
        while (!m_queue.empty()) {
            auto it = m_queue.front();
            m_queue.pop_front();
            it();
        }
    }
   // will add thread safe locks later.        
    void queue(Task task) {
        m_queue.push_back(task);
    }

private:
    TaskQueue m_queue;
};
Queue q;


class WorkMaker : public std::enable_shared_from_this<WorkMaker>
{
public: 

    WorkMaker(int inA) : m_a(inA) {}
    ~WorkMaker() { std::cout << "Destroy " << m_a << std::endl;  }
    void MakeWork() {
        std::shared_ptr<WorkMaker> self = shared_from_this();
        q.queue([self]{
             std::cout << self->m_a << std::endl;
        });
    }
    int m_a;
};

int main()
{
  {
    auto w1 = std::make_shared<WorkMaker>(1);   
    auto w2 = std::make_shared<WorkMaker>(2);    
    w1->MakeWork();
    w2->MakeWork();
  }
  q.flush();
  return 0;
}

我得到了想要的输出:

1
Destroy 1
2
Destory 2

Answer 1

std::function 将创建函数指针、lambda 或其引用的任何内容的私有(private)拷贝。通常，此拷贝是从 std::function 对象引用的，以便以后避免进一步复制。

以这种方式使用 std::function 对象并没有特别慢。但是，您可能应该考虑将 std::vector 替换为 std::deque。