C++11 多线程之传递package_tast讨论

《C++ Concurrency In Action》中有一段这样的示例：

许多GUI框架的GUI更新都是通过一个指定的线程来实现的，所以其他线程如果想更新界面必须给指定的线程发送信号。std:packaged_task提供一种方法，可以不用定义自定义消息，如下：

std::mutex m;  
std::deque<std::packaged_task<void()> > tasks;  
bool gui_shutdown_message_received();  
void get_and_process_gui_message();  
void gui_thread()  
{  
    while (!gui_shutdown_message_received())  
    {  
        get_and_process_gui_message();  
        std::packaged_task<void()> task;  
        {  
            std::lock_guard<std::mutex> lk(m);  
            if (tasks.empty())  
                continue;  
            task = std::move(tasks.front());  
            tasks.pop_front();  
        }  
        task();  
    }  
}  
std::thread gui_bg_thread(gui_thread);  
template<typename Func>  
std::future<void> post_task_for_gui_thread(Func f)  
{  
    std::packaged_task<void()> task(f);  
    std::future<void> res = task.get_future();  
    std::lock_guard<std::mutex> lk(m);  
    tasks.push_back(std::move(task));  
    return res;  
}

不同的线程可以通过post_task_for_gui_thread函数向任务队列中添加任务。GUI后台线程会周期从队列中获取任务，并逐一执行。

问题产生：不够方便

上面的程序有个限制，传递的函数或可调用对象的调用形式只能是：void ()。它不能传递参数，也没有返回值。这就从很大程度上限制了任务的传递。有没有什么办法可以解决这个问题呢？

我们知道，传递的任务最终需要异步执行，此时如果我们希望获取返回值，最好使用std::packaged_tast对象，因为它可以给我们留下一个std::future对象来获取返回值。至于传递参数，因为任务的参数的类型和数量我们不能做任何限制，因此需要用到可变参数模板。

接着分析，我们传递的任务最终要放在队列中，因此需要找个通用的类型用于保存在队列中。

std::bind函数可以将函数(或可调用对象)和可变参数绑定在一起形成一个新的无参数的函数，统一了参数类型为无参数。但是bind函数是具有返回值的，它与被绑定的函数(或可调用对象)的返回值一致。

别着急，std::packaged_task重载了函数调用运算符，返回值是void。因此，我们把由bind函数形成的新函数传递给packaged_task，那么就产生了一个新的可调用对象，它的调用形式是void ()。貌似问题已经基本解决了，那么这个packaged_tast对象是否可以直接放到队列中呢？答案是否定的。因为packaged_tast是个类模板，需要制定参数类型，他的参数类型是它将要保存的函数类型。虽然bind函数产生了一个无参数的调用对象，但是其返回值还是保留了下来，因此packaged_task的模板参数中至少要包含返回类型信息。

当我们思考到这里时，我们至少可以写出如下代码：

mutex mtx;
queue<X> que;
template<typename Fn, typename...Args>
future<typename std::result_of<Fn && (Args&&...)>::type> add_task(Fn&& fn, Args&&... args)
{
    lock_guard<mutex> lk(mtx);
    packaged_task<typename std::result_of<Fn && (Args&&...)>::type()> pa(bind(std::forward<Fn>(fn), std::forward<Args>(args)...));

    auto ret = pa.get_future();
    que.push(X);
    return ret;
}

使用std::function

现在唯一不确定的因素就是packaged_task对象将以什么形式保存在队列中。此时，也许我们会想到std::function类模板，function类模板只需要在模板参数中指定函数的调用形式即可，我们现在的packaged_task对象的调用形式就是void()，好像一切都OK了！但是，结果令人无比沮丧，我们这样生成function对象：

std::function<void()> f(std::move(pa));

我们已经知道packaged_task对象只能move，不能拷贝，因此使用了std::move()函数将其转换为右值，但是编译器仍然告诉我调用了拷贝构造函数：

错误	C2280	“std::packaged_task...&&>::type (void)> &)”: 尝试引用已删除的函数...	

后来在网上查看了一些帖子，说function对象构造时采用的是copy而不是move。一个看起来无比完美的计划就此破灭...

强制转换为void (*)()

将packaged_task对象指针强制转换为void (*)()函数指针，然后再保存在队列中：

template<typename Fn, typename...Args>
future<typename std::result_of<Fn && (Args&&...)>::type> add_task(Fn&& fn, Args&&... args)
{
	lock_guard<mutex> lk(mtx);
	packaged_task<typename std::result_of<Fn && (Args&&...)>::type()> pa(bind(std::forward<Fn>(fn), std::forward<Args>(args)...));

	auto ret = pa.get_future();
	using void_fun = void(*)();
	void_fun fun = void_fun(&pa);
	fun();//运行出错
	(*fun)();//运行出错
	...
}

遗憾的是，这种办法也行不通：转换后的指针在调用时会出错。

利用多态机制，转换为基类指针，隐藏类型细节

最后，试试多态机制。定义一个基类，提供一个虚函数：void operator()() const。然后从其派生一个类模板，保存packaged_task对象，实现虚函数。这样，队列中只保存一个基类指针。经过测试，此办法可行！但是涉及到指针就需要有内存管理，因此将指针改为shared_ptr，这样就完美了。最后，完整的代码如下：

class void_call_base
{
public:
	virtual void operator()() const = 0;
	virtual ~void_call_base() {};
};

template<typename T>
class void_call : public void_call_base
{
public:
	~void_call() {}
	void_call(T &&t) :caller(std::move(t))
	{}
	void_call &operator=(void_call&& other)
	{
		caller = std::move(other);
	}
	virtual void operator()() const override
	{
		caller.operator()();
	}
	void_call(const T &) = delete;
	void_call &operator=(const void_call&) = delete;
private:
	mutable T caller;
};

mutex mtx;
queue<shared_ptr<void_call_base>> que;
bool b_run = true;

void process_task()
{
	while (b_run)
	{
		unique_lock<mutex> lk(mtx);
		if (!que.empty())
		{
			auto p = que.front();
			que.pop();
			lk.unlock();
			(*p)();
		}
	}
}
int f_test(int n)
{
	return n * 2;
}
string f(string &str)
{
	str += "asdfg";
	return str;
}

void ff()
{
}

template<typename Fn, typename...Args>
future<typename std::result_of<Fn && (Args&&...)>::type> add_task(Fn&& fn, Args&&... args)
{
	lock_guard<mutex> lk(mtx);
	packaged_task<typename std::result_of<Fn && (Args&&...)>::type()> pa(bind(std::forward<Fn>(fn), std::forward<Args>(args)...));

	auto ret = pa.get_future();
	que.push(make_shared<void_call<decltype(pa)>>(std::move(pa)));

	return ret;
}

void main()
{
	thread t(process_task);
	auto ret = add_task(f_test, 123);

	string str = "000";
	auto ret1 = add_task(f, std::ref(str));//引用也可以

	cout << ret.get() << endl;
	ret1.get();
	cout << str << endl;
	b_run = false;
	t.join();

	system("pause");
}

效果还不错，引用也可使用，但是需要使用std::ref()。

大家如果有什么更好的办法欢迎来讨论，我的QQ：114211200