修改代码格式及其测试链接，确保类型与对象名字之间存在空格

Author: Mq-b

code/03共享数据/保护不常更新的数据结构.cpp

@@ -17,7 +17,7 @@ class Settings {
     }
 
     std::string get(const std::string& key) const {
-        std::shared_lock<std::shared_mutex> lock(mutex_);
+        std::shared_lock<std::shared_mutex> lock{ mutex_ };
         const auto it = data_.find(key);
         return (it != data_.end()) ? it->second : ""; // 如果没有找到键返回空字符串
     }

md/03共享数据.md

@@ -91,7 +91,7 @@ void f() {
 }
 
 int main() {
-    std::vector<std::thread>threads;
+    std::vector<std::thread> threads;
     for (std::size_t i = 0; i < 10; ++i)
         threads.emplace_back(f);
 
@@ -100,7 +100,7 @@ int main() {
 }
 ```
 
-这段代码你多次[运行](https://godbolt.org/z/K7hcYxec9)它会得到毫无规律和格式的结果，我们可以使用[互斥量](https://zh.cppreference.com/w/cpp/thread/mutex)解决这个问题：
+这段代码你多次[运行](https://godbolt.org/z/93vTzcPzK)它会得到毫无规律和格式的结果，我们可以使用[互斥量](https://zh.cppreference.com/w/cpp/thread/mutex)解决这个问题：
 
 ```cpp
 #include <mutex> // 必要标头
@@ -182,7 +182,7 @@ private:
 void f(){
     //code..
     {
-        std::lock_guard<std::mutex>lc{ m };
+        std::lock_guard<std::mutex> lc{ m };
         // 涉及共享资源的修改的代码...
     }
     //code..
@@ -206,12 +206,12 @@ void add_to_list(int n, std::list<int>& list) {
     int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
 
     {
-        std::lock_guard<std::mutex>lc{ m };
+        std::lock_guard<std::mutex> lc{ m };
         list.push_back(sum);
     }
 }
 void print_list(const std::list<int>& list){
-    std::lock_guard<std::mutex>lc{ m };
+    std::lock_guard<std::mutex> lc{ m };
     for(const auto& i : list){
         std::cout << i << ' ';
     }
@@ -231,7 +231,7 @@ t3.join();
 t4.join();
 ```
 
-> 完整[代码测试](https://godbolt.org/z/ETeEsKhzK)。
+> 完整[代码测试](https://godbolt.org/z/E3396dMxG)。
 
 先看 `add_to_list`，只有 `list.push_back(sum)` 涉及到了对共享数据的修改，需要进行保护，我们用 `{}` 包起来了。
 
@@ -326,7 +326,7 @@ class Data_wrapper{
 public:
     template<class Func>
     void process_data(Func func){
-        std::lock_guard<std::mutex>lc{m};
+        std::lock_guard<std::mutex> lc{m};
         func(data);  // 受保护数据传递给函数
     }
 };
@@ -368,20 +368,20 @@ std::mutex m1,m2;
 std::size_t n{};
 
 void f(){
-    std::lock_guard<std::mutex>lc1{ m1 };
-    std::lock_guard<std::mutex>lc2{ m2 };;
+    std::lock_guard<std::mutex> lc1{ m1 };
+    std::lock_guard<std::mutex> lc2{ m2 };;
     ++n;
 }
 void f2() {
-    std::lock_guard<std::mutex>lc1{ m2 };
-    std::lock_guard<std::mutex>lc2{ m1 };
+    std::lock_guard<std::mutex> lc1{ m2 };
+    std::lock_guard<std::mutex> lc2{ m1 };
     ++n;
 }
 ```
 
  `f` 与 `f2` 因为互斥量**上锁顺序不同**，就有死锁风险。函数 `f` 先锁定 `m1`，然后再尝试锁定 `m2`，而函数 `f2` 先锁定 `m2` 再锁定 `m1` 。如果两个线程同时运行，它们就可能会彼此等待对方释放其所需的锁，从而造成死锁。
 
-> 简而言之，有可能函数 f 锁定了 m1，函数 f2 锁定了 m2，函数 f 要往下执行，给 m2 上锁，所以在等待 f2 解锁 m2，然而函数 f2 也在等待函数 f 解锁 m1 它才能往下执行。所以死锁。[测试代码](https://godbolt.org/z/b9zYs44of)。
+> 简而言之，有可能函数 f 锁定了 m1，函数 f2 锁定了 m2，函数 f 要往下执行，给 m2 上锁，所以在等待 f2 解锁 m2，然而函数 f2 也在等待函数 f 解锁 m1 它才能往下执行。所以死锁。[测试代码](https://godbolt.org/z/T8vWYzqnT)。
 
 ---
 
@@ -399,8 +399,8 @@ private:
 
 void swap(X& lhs, X& rhs) {
     if (&lhs == &rhs) return;
-    std::lock_guard<std::mutex>lock1{ lhs.m }; 
-    std::lock_guard<std::mutex>lock2{ rhs.m }; 
+    std::lock_guard<std::mutex> lock1{ lhs.m }; 
+    std::lock_guard<std::mutex> lock2{ rhs.m }; 
     swap(lhs.object, rhs.object);
 }
 ```
@@ -417,7 +417,7 @@ std::thread t2{ [&] {swap(b, a); } }; // 2
 
 `2` 执行的时候，先上锁 b 的互斥量，再上锁 a 的互斥量。
 
-> 完全可能线程 A 执行 1 的时候上锁了 a 的互斥量，线程 B 执行 `2` 上锁了 b 的互斥量。线程 A 往下执行需要上锁 b 的互斥量，线程 B 则要上锁 a 的互斥量执行完毕才能解锁，哪个都没办法往下执行，**死锁**。[测试代码](https://godbolt.org/z/eYbjqEx54)。
+> 完全可能线程 A 执行 1 的时候上锁了 a 的互斥量，线程 B 执行 `2` 上锁了 b 的互斥量。线程 A 往下执行需要上锁 b 的互斥量，线程 B 则要上锁 a 的互斥量执行完毕才能解锁，哪个都没办法往下执行，**死锁**。[测试代码](https://godbolt.org/z/M6hfeb778)。
 
 其实也就是回到了第一个示例的问题。
 
@@ -427,8 +427,8 @@ C++ 标准库有很多办法解决这个问题，**可以使用 [`std::lock`](ht
 void swap(X& lhs, X& rhs) {
     if (&lhs == &rhs) return;
     std::lock(lhs.m, rhs.m);    // 给两个互斥量上锁
-    std::lock_guard<std::mutex>lock1{ lhs.m,std::adopt_lock }; 
-    std::lock_guard<std::mutex>lock2{ rhs.m,std::adopt_lock }; 
+    std::lock_guard<std::mutex> lock1{ lhs.m,std::adopt_lock }; 
+    std::lock_guard<std::mutex> lock2{ rhs.m,std::adopt_lock }; 
     swap(lhs.object, rhs.object);
 }
 ```
@@ -476,8 +476,8 @@ void swap(X& lhs, X& rhs) {
 ```cpp
 void swap(X& lhs, X& rhs) {
     if (&lhs == &rhs) return;
-    std::unique_lock<std::mutex>lock1{ lhs.m, std::defer_lock };
-    std::unique_lock<std::mutex>lock2{ rhs.m, std::defer_lock };
+    std::unique_lock<std::mutex> lock1{ lhs.m, std::defer_lock };
+    std::unique_lock<std::mutex> lock2{ rhs.m, std::defer_lock };
     std::lock(lock1, lock2);
     swap(lhs.object, rhs.object);
     ++n;
@@ -563,7 +563,7 @@ std::mutex m;
 
 int main() {
     m.lock();
-    std::unique_lock<std::mutex>lock{ m,std::adopt_lock };
+    std::unique_lock<std::mutex>lock { m,std::adopt_lock };
 }
 ```
 
@@ -583,7 +583,7 @@ int main() {
 void f() {
     //code..
 
-    std::unique_lock<std::mutex>lock{ m };
+    std::unique_lock<std::mutex> lock{ m };
 
     // 涉及共享资源的修改的代码...
 
@@ -621,12 +621,12 @@ void f() {
 ```cpp
 std::unique_lock<std::mutex>get_lock(){
     extern std::mutex some_mutex;
-    std::unique_lock<std::mutex>lk{ some_mutex };
+    std::unique_lock<std::mutex> lk{ some_mutex };
     return lk;
 
 }
 void process_data(){
-    std::unique_lock<std::mutex>lk{ get_lock() };
+    std::unique_lock<std::mutex> lk{ get_lock() };
     // 执行一些任务...
 }
 ```
@@ -639,7 +639,7 @@ void process_data(){
 
 如果你简单写一个 `std::mutex some_mutex` 那么函数  `process_data` 中的 `lk` 会持有一个悬垂指针。
 
-> 举一个使用 `extern std::mutex` 的完整[运行示例](https://godbolt.org/z/bWv5fcdGf)。当然，其实理论上你 `new std::mutex` 也是完全可行...... 🤣🤣
+> 举一个使用 `extern std::mutex` 的完整[运行示例](https://godbolt.org/z/z47x1Es5z)。当然，其实理论上你 `new std::mutex` 也是完全可行...... 🤣🤣
 
 `std::unique_lock` 是灵活的，同样允许在对象销毁之前就解锁互斥量，调用 `unlock()` 成员函数即可，不再强调。
 
@@ -654,7 +654,7 @@ void process_data(){
    ```cpp
    void f(){
        if(!ptr){      // 1
-           std::lock_guard<std::mutex>lk{ m };
+           std::lock_guard<std::mutex> lk{ m };
            if(!ptr){  // 2
                ptr.reset(new some);  // 3
            }
@@ -755,7 +755,7 @@ private:
 
 public:
     void set(const std::string& key, const std::string& value) {
-        std::lock_guard<std::shared_mutex> lock(mutex_);
+        std::lock_guard<std::shared_mutex> lock{ mutex_ };
         data_[key] = value;
     }
 
@@ -767,7 +767,7 @@ public:
 };
 ```
 
-> [完整代码](https://github.com/Mq-b/ModernCpp-ConcurrentProgramming-Tutorial/blob/main/code/03共享数据/保护不常更新的数据结构.cpp)。[测试](https://godbolt.org/z/KG84rb8qd)链接。标准输出可能交错，但无数据竞争。
+> [完整代码](https://github.com/Mq-b/ModernCpp-ConcurrentProgramming-Tutorial/blob/main/code/03共享数据/保护不常更新的数据结构.cpp)。[测试](https://godbolt.org/z/ezh1Pdo5E)链接。标准输出可能交错，但无数据竞争。
 
 `std::shared_timed_mutex` 具有 `std::shared_mutex` 的所有功能，并且额外支持超时功能。所以以上代码可以随意更换这两个互斥量。
 
@@ -815,15 +815,15 @@ int main() {
 
 ```cpp
 void recursive_function(int count) {
-    std::lock_guard<std::recursive_mutex>lc{ mtx };
+    std::lock_guard<std::recursive_mutex> lc{ mtx };
     std::cout << "Locked by thread: " << std::this_thread::get_id() << ", count: " << count << std::endl;
     if (count > 0) {
         recursive_function(count - 1);
     }
 }
 ```
 
-> [运行](https://godbolt.org/z/rqG613W94)测试。
+> [运行](https://godbolt.org/z/d63zrG1cK)测试。
 
 ## `new`、`delete` 是线程安全的吗？