标准互斥或增强互斥？ 哪个更好？

Question

What is the real difference between std::mutex and boost::mutex? Which one is faster in terms of implementation and compilation? Are both of them portable?I read my questions related to it but there is no clear mention of difference . std mutex is supported only since c++11 so the older compilers dont support it . Are boost mutex supported by older compilers or not? If the foremost condition requires the code to be portable , then what should be prefered?

Answer 1

As a default choice you should prefer std:: anything to boost:: samething because it's a part of standard library and hence is more portable since it doesn't introduce external dependency.

You can't really compare std::mutex and boost::mutex in general because there is no one and only std::mutex , it's implementation depends on the standard library implementation that you are using which usually is a part of your toolchain.

There might be a case when you discover using empirical evidence that std::mutex you are using is in some regard "worse" than boots::mutex . In this case it might be reasonable to switch to it, but only if it's really justified and you have an actual evidence (eg performance measurement) of that. Even then it seems like a last resort. It might be better to switch to a different standard library implementation or to a different toolchain or upgrade your current one if possible.

Answer 2

@ std::mutex for me every time, for the reason @Henri states it is (obviously) part of the C++ standard so you can rely on it being available everywhere.

Using boost, on the other hand, means that you have to link against the boost library. While this is widely available and offers a number of handy extra features it's quite heavyweight and you wouldn't want to pull it in just for this.

Also, std::mutex may be faster. The cross-platform nature of boost means that things that rely on OS support (which would include mutexes) can sometimes be less efficient. But this would not be a major factor in my thinking.

But if measuring performance is important to you, you should run your own benchmark. You can do this (roughly) over at (say) Wandbox - they support the boost library there.

Answer 3

Consider boost as a laboratory for prototyping std features. Many std facilities were originally implemented on boost. The difference is that std takes care of consistency and forward compatiblity, while boost targets new horizons. Nothing prevents boost from applying breaking changes in forth coming versions, but it also provides answers to more questions than std. My personal preference is std first - when possible - and boost next - when needed. I generally avoid pre c++11 platforms, unless I am forced to face.

Answer 4

The focus of Boost is trying new techniques and introducing new capabilities. The focus of the C++ standard is specifying requirements in a way that (in most cases) can be implemented portably. A number of features from boost have found their way into the C++ standard, but were often changed quite a bit in that transition - to improve portability, sometimes improve reliability, etc.

If your implementation (compiler and library) is C++11 or later, and you intend to not to port to older implementations, then definitely use std::mutex . It is part of the standard, from 2011, so preferable. No need to rely on third-party libraries. You will only need boost if you need bleeding edge features of boost that the C++ standard does not support (which means things other than mutex ).

Some exceptions to the above: there are some features of boost (including related to threading and mutexes) that haven't made their way into a C++ standard, and some features in the C++ standard that are not in boost.

If you need to use (or support or port to) an older implementation, then consider using boost::mutex . You will, in most cases, need to install a version of boost separately, with your chosen implementation (some compiler versions have shipped with a version of boost, but don't rely on it). If there isn't a version of boost that works with your compiler/library, then (to state the obvious) you will not be able to use boost::mutex .

Boost has had the thread library (which includes mutex ) since about version 1.25.0, which dates from late 2001. Which suggests boost is an option if your compiler is no older than (rough guess) early 2000s.

If you need to support an implementation that is significantly older than the early 2000s, then you may be out of luck using boost::mutex , and will need to resort to other libraries/frameworks or get your hands dirty writing OS-specific code.