用 c++11 等价物替换 boost::thread 和 boost::mutex 是否明智?
动机:我之所以考虑它是因为我的天才项目经理认为 boost 是另一种依赖,而且它很可怕,因为你依赖它"(我尝试解释 boost 的质量,然后在一段时间后放弃了时间 :( ). 我想做它的较小原因是我想学习 c++11 特性,因为人们会开始在其中编写代码.所以:
Motivation: reason why I'm considering it is that my genius project manager thinks that boost is another dependency and that it is horrible because "you depend on it"(I tried explaining the quality of boost, then gave up after some time :( ). Smaller reason why I would like to do it is that I would like to learn c++11 features, because people will start writing code in it. So:
#include
和提升等价物?之间是否存在 1:1 映射?#include - 你认为用 c++11 替换 boost 的东西是个好主意吗
东西.我的用法很原始,但有没有 std 不使用的例子提供什么提升呢?或者(亵渎)反之亦然?
附言我使用 GCC,所以标题在那里.
P.S. I use GCC so headers are there.
推荐答案
Boost.Thread 和 C++11 标准线程库有几个不同点:
There are several differences between Boost.Thread and the C++11 standard thread library:
- Boost 支持线程取消,C++11 线程不支持
- C++11 支持
std::async
,但 Boost 不支持 - Boost 有一个
boost::shared_mutex
用于多读/单写锁定.类似的std::shared_timed_mutex
仅从 C++14 开始可用 (N3891),而std::shared_mutex
仅在 C++17 后可用(N4508). - C++11 超时与 Boost 超时不同(尽管现在 Boost.Chrono 已被接受,这应该很快就会改变).
- 有些名称不同(例如
boost::unique_future
与std::future
) std::thread
的参数传递语义不同于boost::thread
--- Boost 使用boost::bind
,这需要可复制的参数.std::thread
允许将诸如std::unique_ptr
之类的仅移动类型作为参数传递.由于使用了boost::bind
,嵌套绑定表达式中的占位符(例如_1
)的语义也可能不同.- 如果您没有显式调用
join()
或detach()
那么boost::thread
析构函数和赋值运算符将调用detach()
在被销毁/分配给的线程对象上.对于 C++11std::thread
对象,这将导致调用std::terminate()
并中止应用程序.
- Boost supports thread cancellation, C++11 threads do not
- C++11 supports
std::async
, but Boost does not - Boost has a
boost::shared_mutex
for multiple-reader/single-writer locking. The analogousstd::shared_timed_mutex
is available only since C++14 (N3891), whilestd::shared_mutex
is available only since C++17 (N4508). - C++11 timeouts are different to Boost timeouts (though this should soon change now Boost.Chrono has been accepted).
- Some of the names are different (e.g.
boost::unique_future
vsstd::future
) - The argument-passing semantics of
std::thread
are different toboost::thread
--- Boost usesboost::bind
, which requires copyable arguments.std::thread
allows move-only types such asstd::unique_ptr
to be passed as arguments. Due to the use ofboost::bind
, the semantics of placeholders such as_1
in nested bind expressions can be different too. - If you don't explicitly call
join()
ordetach()
then theboost::thread
destructor and assignment operator will calldetach()
on the thread object being destroyed/assigned to. With a C++11std::thread
object, this will result in a call tostd::terminate()
and abort the application.
为了澄清关于仅移动参数的观点,以下是有效的 C++11,并将 int
的所有权从临时 std::unique_ptr
转移新线程启动时f1
的参数.但是,如果您使用 boost::thread
那么它将无法工作,因为它在内部使用 boost::bind
和 std::unique_ptr
> 无法复制.GCC 提供的 C++11 线程库中也有一个错误,它阻止了这项工作,因为它在那里的实现中也使用了 std::bind
.
To clarify the point about move-only parameters, the following is valid C++11, and transfers the ownership of the int
from the temporary std::unique_ptr
to the parameter of f1
when the new thread is started. However, if you use boost::thread
then it won't work, as it uses boost::bind
internally, and std::unique_ptr
cannot be copied. There is also a bug in the C++11 thread library provided with GCC that prevents this working, as it uses std::bind
in the implementation there too.
void f1(std::unique_ptr<int>);
std::thread t1(f1,std::unique_ptr<int>(new int(42)));
如果您正在使用 Boost,那么如果您的编译器支持它,那么您可能可以相对轻松地切换到 C++11 线程(例如,Linux 上的最新版本的 GCC 具有 C++11 线程库的基本完整实现,可在-std=c++0x
模式).
If you are using Boost then you can probably switch to C++11 threads relatively painlessly if your compiler supports it (e.g. recent versions of GCC on linux have a mostly-complete implementation of the C++11 thread library available in -std=c++0x
mode).
如果您的编译器不支持 C++11 线程,那么您可以使用第三方实现,例如 Just::线程,但这仍然是一个依赖项.
If your compiler doesn't support C++11 threads then you may be able to get a third-party implementation such as Just::Thread, but this is still a dependency.
相关文章