1. 修改阅读须知展示代码风格的示例

2. 修改 `std::future` 支持只能移动类型的示例
3. 新增一节“future 的状态变化”，主要聊 `get` 的特殊情况以及部分源码解析

Author: Mq-b

md/04同步操作.md

@@ -343,33 +343,36 @@ std::async(f, n);   // OK! 可以通过编译，不过引用的并非是局部
 std::async(f2, n);  // Error! 无法通过编译
 ```
 
-我们来展示使用 `std::move` ，也就移动传递参数：
+我们来展示使用 `std::move` ，也就是移动传递参数并接受返回值：
 
 ```cpp
-struct move_only {
+struct move_only{
     move_only() { std::puts("默认构造"); }
-    move_only(const move_only&) = delete;
-    move_only(move_only&&)noexcept {
-        std::puts("移动构造");
+    move_only(move_only&&)noexcept { std::puts("移动构造"); }
+    move_only& operator=(move_only&&) noexcept {
+        std::puts("移动赋值");
+        return *this;
     }
+    move_only(const move_only&) = delete;
 };
 
-void task(move_only x){
+move_only task(move_only x){
     std::cout << "异步任务 ID: " << std::this_thread::get_id() << '\n';
+    return x;
 }
 
 int main(){
     move_only x;
-    std::future<void> future = std::async(task, std::move(x));
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    std::future<move_only> future = std::async(task, std::move(x));
+    std::this_thread::sleep_for(std::chrono::seconds(1));
     std::cout << "main\n";
-    future.wait();  // 等待异步任务执行完毕
+    move_only result = future.get();  // 等待异步任务执行完毕
 }
 ```
 
-> [运行](https://godbolt.org/z/fY9Md3nzz)测试。
+> [运行](https://godbolt.org/z/5cfvdEWWh)测试。
 
-如你所见，它**支持只移动类型**，我们将参数使用 `std::move` 传递。
+如你所见，它**支持只移动类型**，我们将参数使用 `std::move` 传递，接收参数的时候直接调用 `get` 函数即可。
 
 ---
 
@@ -672,6 +675,57 @@ int main() {
 来自 set_exception 的异常: promise already satisfied
 ```
 
+### future 的状态变化
+
+需要注意的是，**future 是一次性的**，所以你需要注意移动。并且，调用 `get` 函数后，future 对象也会**失去共享状态**。
+
+- **移动语义**：这一点很好理解并且常见，因为**移动操作标志着所有权的转移**，意味着 `future` 不再拥有共享状态（如之前所提到）。`get` 和 `wait` 函数要求 `future` 对象拥有共享状态，否则会抛出异常。
+- **共享状态失效**：调用 `get` 成员函数时，`future` 对象必须拥有共享状态，但调用完成后，它就会**失去共享状态**，不能再次调用 `get`。这是我们在本节需要特别讨论的内容。
+
+```cpp
+std::future<void>future = std::async([] {});
+std::cout << std::boolalpha << future.valid() << '\n'; // true
+future.get();
+std::cout << std::boolalpha << future.valid() << '\n'; // false
+try {
+    future.get(); // 抛出 future_errc::no_state 异常
+}
+catch (std::exception& e) {
+    std::cerr << e.what() << '\n';
+}
+```
+
+> [运行](https://godbolt.org/z/hvfMGnMbj)测试。
+
+这个问题在许多文档中没有明确说明，但通过阅读源码（[MSVC STL](https://github.com/microsoft/STL/blob/f54203f/stl/inc/future)），可以很清楚地理解：
+
+```cpp
+// std::future<void>
+void get() {
+    // block until ready then return or throw the stored exception
+    future _Local{_STD move(*this)};
+    _Local._Get_value();
+}
+// std::future<T>
+_Ty get() {
+    // block until ready then return the stored result or throw the stored exception
+    future _Local{_STD move(*this)};
+    return _STD move(_Local._Get_value());
+}
+// std::future<T&>
+_Ty& get() {
+    // block until ready then return the stored result or throw the stored exception
+    future _Local{_STD move(*this)};
+    return *_Local._Get_value();
+}
+```
+
+如上所示，我们展示了 `std::future` 的所有特化 `get` 成员函数的实现。注意到了吗？尽管我们可能不了解移动构造函数的具体实现，但根据通用的语义，可以看出 `future _Local{_STD move(*this)};` 将当前对象的共享状态转移给了这个局部对象，而局部对象在函数结束时析构。这意味着当前对象失去共享状态，并且状态被完全销毁。
+
+另外一提，`std::future<T>` 这个特化，它 `return std::move` 是为了支持只能移动的类型能够使用 `get` 返回值，参见前文的 `move_only` 类型。
+
+如果需要进行多次 `get` 调用，可以考虑使用下文提到的 `std::shared_future`。
+
 ### 多个线程的等待
 
 之前的例子中都在用 `std::future` ，不过 `std::future` 也有局限性。很多线程在等待的时候，只有一个线程能获取结果。当多个线程等待相同事件的结果时，就需要使用 `std::shared_future` 来替代 `std::future` 了。`std::future` 与 `std::shared_future` 的区别就如同 `std::unique_ptr`、`std::shared_ptr` 一样。

md/README.md

@@ -21,16 +21,17 @@
   我们的代码风格较为简洁明了，命名全部使用下划线连接，而不是驼峰命名法。花括号通常只占一行，简短的代码可以不额外占行。一般初始化时使用 `{}`，而非 `()` 或者 `=` 。这样简单直观，避免歧义和许多问题。`#include` 引入头文件时需要在尖括号或引号前后加空格。
 
 ```cpp
-#include <iostream> // 空格
-struct move_only {
+struct move_only{
     move_only() { std::puts("默认构造"); }
-    move_only(const move_only&) = delete;
-    move_only(move_only&&)noexcept {
-        std::puts("移动构造");
+    move_only(move_only&&)noexcept { std::puts("移动构造"); }
+    move_only& operator=(move_only&&) noexcept {
+        std::puts("移动赋值");
+        return *this;
     }
+    move_only(const move_only&) = delete;
 };
 
-int main() {
+int main(){
     move_only m{};
     char buffer[1024]{} // 全部初始化为 0
 }