一道描述很简洁并且涉及C++高级语言特性的题目

题目的描述很简单，就是实现一个机制使得可以很容易地在多线程情况下serialize输出流（例如cout / cerr）—— 估计大多数debug过多线程程序的人都遇到过这样的需求，而且这个问题目前Stack Overflow上并没有比较好的答案。

举个例子，如果让两个线程同时循环执行下面这句输出语句：
--
std::cout << "This is thread " << id << std::endl;
--

那么默认的cout的原子性只作用到单个<<符号，也就是说输出并不一定是
--
This is thread 1
This is thread 2
...
--
这样一句一句的打出来，而可能会变成
--
This is thread This is thread 1
2
...
--
这样。也就是说一个线程的一整句话还没打完，另一个线程的输出就插进来了。

那么，为了比较优雅地处理这种多线程情况下完整输出一句话的需求，我们希望设计一个类似Java下面synchronized关键字的机制，使得每个线程只要用下列语句：
--
synchronized(std::cout) << "This is thread " << id << "\n";
--
就能保证输出时单个statement的完整性。

题目就是问这个synchronized该如何实现？


PS：这个问题其实挺适合当C++面试题的，因为它涉及到某个只有C++有而C无法模拟的特性，以及对对象生存期的理解。

上面两个答案都是正确的，各有适用的场景

这里再稍微解释一下.. 主帖里所说的C++特有的特性就是RAII（Resource Acquisition Is Initialization），例如std::unique_ptr、std::lock_guard都是典型的RAII应用。更多的介绍网上有很多，比如这个： https://oxnz.github.io/2015/07/23/cpp-raii/

而C基本上是无法模拟RAII特性的，即使用macro糊出来一个也不具有composability（简单来说就是不好用），用C写的代码如果涉及多种资源的分配释放并且中间有abort逻辑的话，一般是在函数底部写一串label然后各种goto，比如这个：https://vilimpoc.org/research/raii-in-c/

此外楼上Airtnp回答了对象生存期的相关内容，也就是对于 synchronized(std::cout) << "This is thread " << id << "\n" 这样的表达式，临时对象synchronized(std::cout)的生存期是长于其所在整体表达式的生存期的，所以“synchronized”的destructor会在所有“<<”都执行完之后才执行。

LB4195450681 发表于 2019-5-24 04:30
多谢分享，以前从不知道20有这样的东西。不过Only available in C++20感觉短时间无法用到啊...

https://wandbox.org/permlink/sjTy71dtqDcK1iqW

我就随便写写举个例子哈...没测过但这么做当玩具用应该就行了
libstdc++和libcxx都还没实现（

1. #include <algorithm>
   
2. #include <future>
   
3. #include <iostream>
   
4. #include <map>
   
5. #include <memory>
   
6. #include <mutex>
   
7. #include <queue>
   
8. #include <set>
   
9. #include <vector>
   
10. 
    
11. using namespace std;
    
12. 
    
13. template <typename Stream> class SyncStream {
    
14. public:
    
15.   SyncStream(Stream &stream) : stream_(&stream) { mutex_.lock(); }
    
16. 
    
17.   ~SyncStream() { mutex_.unlock(); }
    
18. 
    
19.   template <typename T> SyncStream &operator<<(const T &rhs) {
    
20.     (*stream_) << rhs;
    
21.     return *this;
    
22.   }
    
23. 
    
24.   SyncStream &operator<<(std::ostream &(*manip)(std::ostream &)) {
    
25.     (*stream_) << manip;
    
26.     return *this;
    
27.   }
    
28. 
    
29. private:
    
30.   static std::mutex mutex_;
    
31.   Stream *stream_;
    
32. };
    
33. 
    
34. template <typename Stream> std::mutex SyncStream<Stream>::mutex_;
    
35. 
    
36. template <typename Stream> SyncStream<Stream> synchronized(Stream &stream) {
    
37.   return SyncStream<Stream>(stream);
    
38. }
    
39. 
    
40. int main() {
    
41.   const int n = 100;
    
42.   std::vector<std::future<void>> futures(n);
    
43.   for (int i = 0; i < n; ++i) {
    
44.     futures[i] = std::async(std::launch::async, [i]() {
    
45.       std::this_thread::sleep_for(std::chrono::milliseconds(1));
    
46.       synchronized(std::cout) << "thread id " << i << std::endl;
    
47.     });
    
48.   }
    
49.   for (const auto &future : futures) {
    
50.     future.wait();
    
51.   }
    
52.   return 0;
    
53. }

复制代码

不知道是否正确，manip的部分是从SO一个回答上抄的

PS：这个问题其实挺适合当C++面试题的，因为它涉及到某个只有C++有而C无法模拟的特性，以及对对象生存期的理解。

几个月前面试遇到

https://en.cppreference.com/w/cpp/io/basic_osyncstream

scope里存
dtor一起交

补充内容 (2019-5-23 21:18):
lifetime ends when whole expression ends，所以直接写在最前面也行

Airtnp 发表于 2019-5-22 17:47
https://en.cppreference.com/w/cpp/io/basic_osyncstream

scope里存

多谢分享，以前从不知道20有这样的东西。不过Only available in C++20感觉短时间无法用到啊...