假设通过新线程返回的所有权去调用一个需要后台启动线程的函数,并需要在函数中转移线程的所有权。这些操作都要等待线程结束才能进行,并且需要线程的所有权能够进行转移。
这就是将移动操作引入std::thread
的原因,C++标准库中有很多资源占有(resource-owning)类型,比如std::ifstream
,std::unique_ptr
还有std::thread
都是可移动,但不可复制。这说明执行线程的所有权可以在std::thread
实例中移动,下面将展示一个例子。例子中,创建了两个执行线程,并在std::thread
实例之间t1,t2和t3t1,t2和t3转移所有权:
- void some_function();
- void some_other_function();
- std::thread t1(some_function); // 1
- std::thread t2 = std::move(t1); // 2
- t1 = std::thread(some_other_function); // 3
- std::thread t3; // 4
- t3 = std::move(t2); // 5
- t1 = std::move(t3); // 6 赋值操作将使程序崩溃
首先,新线程与t1相关联①。当显式使用std::move()
创建t2后②,t1的所有权就转移给了t2。之后,t1和执行线程已经没有关联了,执行some_function的函数线程与t2关联。
然后,临时std::thread
对象相关的线程启动了③。为什么不显式调用std::move()
转移所有权呢?因为,所有者是一个临时对象——移动操作将会隐式的调用。
t3使用默认构造方式创建④,没有与任何线程进行关联。调用std::move()
将t2关联线程的所有权转移到t3中⑤。因为t2是一个命名对象,需要显式的调用std::move()
。移动操作⑤完成后,t1与执行some_other_function的线程相关联,t2与任何线程都无关联,t3与执行some_function的线程相关联。
最后一个移动操作,将some_function线程的所有权转移⑥给t1。不过,t1已经有了一个关联的线程执行some_other_function的线程,所以这里系统直接调用std::terminate()
终止程序继续运行。这样做(不抛出异常,std::terminate()
是noexcept函数)是为了保证与std::thread
的析构函数的行为一致。需要在线程对象析构前,显式的等待线程完成,或者分离它,进行赋值时也需要满足这些条件(说明:不能通过赋新值给std::thread对象的方式来"丢弃"一个线程)
std::thread
支持移动,线程的所有权可以在函数外进行转移,就如下面程序一样。
函数返回std::thread对象
- std::thread f()
- {
- void some_function();
- return std::thread(some_function);
- }
-
- std::thread g()
- {
- void some_other_function(int);
- std::thread t(some_other_function,42);
- return t;
- }
当所有权可以在函数内部传递,就允许std::thread
实例作为参数进行传递,代码如下:
- void f(std::thread t);
- void g()
- {
- void some_function();
- f(std::thread(some_function));
- std::thread t(some_function);
- f(std::move(t));
- }
std::thread
支持移动可以创建thread_guard类的实例,并且拥有线程所有权。当引用thread_guard对象所持有的线程时,移动操作就可以避免很多不必要的麻烦。当某个对象转移了线程的所有权,就不能对线程进行汇入或分离。为了确保线程在程序退出前完成,定义了scoped_thread类。现在,我们来看一下这个类型:
- class scoped_thread
- {
- std::thread t;
- public:
- explicit scoped_thread(std::thread t_) // 1
- :t(std::move(t_))
- {
- if (!t.joinable()) // 2
- throw std::logic_error("No thread");
- }
- ~scoped_thread()
- {
- t.join(); // 3
- }
-
- scoped_thread(scoped_thread const&) = delete;
- scoped_thread& operator=(scoped_thread const&) = delete;
- };
-
- struct func;
-
- void f()
- {
- int some_local_state;
- scoped_thread t(std::thread{ func(some_local_state )}); // 4
- do_something_in_current_thread();
- } // 5
该代码中,新线程会直接传递到scoped_thread中④,而非创建一个独立变量。当主线程到达f()末尾时⑤,scoped_thread对象就会销毁,然后在析构函数中完成汇入③。thread_guard类,需要在析构中检查线程是否“可汇入”。这里把检查放在了构造函数中②,并且当线程不可汇入时抛出异常。
C++17标准给出一个建议,就是添加一个joining_thread的类型,这个类型与std::thread
类似,不同是的添加了析构函数,就类似于scoped_thread。委员会成员们对此并没有达成统一共识,所以这个类没有添加入C++17标准中(C++20仍旧对这种方式进行探讨,不过名称为std::jthread
),这个类实现起来也不是很困难。
- class joining_thread
- {
- std::thread t;
- public:
- joining_thread() noexcept = default;
- template<typename Callable, typename ...Args>
- explicit joining_thread(Callable&& func, Args&& ...args):
- t(std::forward
(func), std::forward(args)...) - {}
-
- explicit joining_thread(std::thread t_) noexcept
- :t(std::move(t_))
- {}
-
- joining_thread(joining_thread&& other) noexcept
- :t(std::move(other.t))
- {}
-
- joining_thread& operator=(joining_thread&& other) noexcept
- {
- if (joinable())
- join();
- t = std::move(other.t);
- return *this;
- }
-
- joining_thread& operator=(std::thread other) noexcept
- {
- if (joinable())
- join();
- t = std::move(other);
- return *this;
- }
-
- void swap(joining_thread& other) noexcept
- {
- t.swap(other.t);
- }
- std::thread::id get_id() const noexcept {
- return t.get_id();
- }
-
- ~joining_thread()
- {
- if (joinable())
- join();
- }
-
- bool joinable() const noexcept
- {
- return t.joinable();
- }
-
- void join()
- {
- t.join();
- }
-
- void detach()
- {
- t.detach();
- }
-
- std::thread& as_thread() noexcept
- {
- return t;
- }
- const std::thread& as_thread() const noexcept
- {
- return t;
- }
- };
std::thread
中对移动语义的支持,也适用于使用std::thread
的移动敏感(move-aware)容器(比如,std::vector<>
)。了解这些后,就可以量产了一些线程,并且等待它们结束,代码如下所示。
量产线程,代码如下:
- std::vector
threads; - for (unsigned i = 0; i < 10; ++i)
- {
- threads.emplace_back(hello);
- }
-
- for (auto& entry : threads)
- entry.join();
将std::thread
放入std::vector
是向线程自动化管理迈出的第一步:并非为这些线程创建独立的变量,而是把它们当做一个组。创建一组线程数量在运行时确定。