更新视频代码

Author: Mq-b

code/ModernCpp-ConcurrentProgramming-Tutorial/42atomic_flag实现自旋锁.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+#include <atomic>
+#include <mutex>
+#include <thread>
+
+class spinlock_mutex {
+    std::atomic_flag flag{};
+public:
+    spinlock_mutex()noexcept = default;
+    void lock()noexcept {
+        while (flag.test_and_set(std::memory_order_acquire));
+    }
+
+    void unlock()noexcept {
+        flag.clear(std::memory_order_release);
+    }
+};
+
+spinlock_mutex m;
+
+void f() {
+    std::lock_guard<spinlock_mutex> lc{ m };
+    std::cout << "😅😅" << "❤️❤️\n";
+}
+
+int main(){
+    std::thread t{ f };
+    std::thread t1{ f };
+    std::thread t2{ f };
+    std::thread t3{ f };
+    std::thread t4{ f };
+    std::thread t5{ f };
+    t.join();
+    t1.join();
+    t2.join();
+    t3.join();
+    t4.join();
+    t5.join();
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/43atomic_bool.cpp

@@ -0,0 +1,25 @@
+#include <atomic>
+#include <iostream>
+#include <thread>
+
+std::atomic<bool> flag{ false };
+bool expected = false;
+
+void try_set_flag() {
+    // 尝试将 flag 设置为 true，如果当前值为 false
+    if (flag.compare_exchange_strong(expected, true)) {
+        std::cout << "flag 为 false，flag 设为 true。\n";
+    }
+    else {
+        std::cout << "flag 为 true, expected 设为 true。\n";
+    }
+}
+
+int main() {
+    std::thread t1{ try_set_flag };
+    std::thread t2{ try_set_flag };
+    t1.join();
+    t2.join();
+    std::cout << "flag: " << std::boolalpha << flag << '\n';
+    std::cout << "expected: " << std::boolalpha << expected << '\n';
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/44atomic指针特化.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+
+struct X{
+    int v{};
+    void f()const {
+        std::cout << v << '\n';
+    }
+};
+
+int main(){
+    int arr[10]{ 1,2 };
+
+    std::atomic<int*> p{ arr };
+
+    p.fetch_add(1);
+    std::cout << *(p.load()) << '\n';
+
+    p.fetch_sub(1);
+    std::cout << *(p.load()) << '\n';
+
+    p += 1;
+    std::cout << *(p.load()) << '\n';
+
+    p -= 1;
+    std::cout << *(p.load()) << '\n';
+
+    X xs[3]{ {10},{20},{30} };
+    std::atomic<X*> p2{ xs };
+    p2.load()->f();
+    p2 += 2;
+    p2.load()->f();
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/45原子特化shared_ptr.cpp

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <memory>
+#include <thread>
+#include <chrono>
+#include <syncstream>
+using namespace std::chrono_literals;
+
+class Data {
+public:
+    Data(int value = 0) : value_(value) {}
+    int get_value() const { return value_; }
+    void set_value(int new_value) { value_ = new_value; }
+private:
+    int value_;
+};
+
+std::atomic<std::shared_ptr<Data>> data = std::make_shared<Data>();
+
+void writer() {
+    for (int i = 0; i < 10; ++i) {
+        std::shared_ptr<Data> new_data = std::make_shared<Data>(i);
+        data.store(new_data); 
+        std::this_thread::sleep_for(100ms);
+    }
+}
+
+void reader() {
+    for (int i = 0; i < 10; ++i) {
+        if (auto sp = data.load()) {
+            std::cout << "读取线程值: " << sp->get_value() << std::endl;
+        }
+        else {
+            std::cout << "没有读取到数据" << std::endl;
+        }
+        std::this_thread::sleep_for(100ms);
+    }
+}
+
+std::atomic<std::shared_ptr<int>> ptr = std::make_shared<int>();
+
+void wait_for_wake_up() {
+    std::osyncstream{ std::cout }
+        << "线程 "
+        << std::this_thread::get_id()
+        << " 阻塞，等待更新唤醒\n";
+
+    // 等待 ptr 变为其它值
+    ptr.wait(ptr.load());
+
+    std::osyncstream{ std::cout }
+        << "线程 "
+        << std::this_thread::get_id()
+        << " 已被唤醒\n";
+}
+
+void wake_up() {
+    std::this_thread::sleep_for(5s);
+
+    // 更新值并唤醒
+    ptr.store(std::make_shared<int>(10));
+    ptr.notify_one();
+}
+
+int main() {
+    //std::thread writer_thread{ writer };
+    //std::thread reader_thread{ reader };
+
+    //writer_thread.join();
+    //reader_thread.join();
+
+    //std::atomic<std::shared_ptr<int>> ptr = std::make_shared<int>(10);
+    //std::atomic_ref<int> ref{ *ptr.load() };
+    //ref = 100; // 原子地赋 100 给被引用的对象
+    //std::cout << *ptr.load() << '\n';
+    std::thread t1{ wait_for_wake_up };
+    wake_up();
+    t1.join();
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/CMakeLists.txt

@@ -12,7 +12,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "C
     add_compile_options("-finput-charset=UTF-8" "-fexec-charset=UTF-8" "-fopenmp")
 endif()
 
-add_executable(${PROJECT_NAME} "41实现一个线程池.cpp")
+add_executable(${PROJECT_NAME} "45原子特化shared_ptr.cpp")
 
 set(SFML_DIR "D:/lib/SFML-2.6.1-windows-vc17-64-bit/SFML-2.6.1/lib/cmake/SFML")
 find_package(SFML 2.6.1 COMPONENTS system window graphics audio network REQUIRED)

md/05内存模型与原子操作.md

@@ -311,7 +311,7 @@ void f(){
 
 稍微聊一下原理，我们的 `spinlock_mutex` 对象中存储的 `flag` 对象在默认构造时是清除 (`false`) 状态。在 `lock()` 函数中调用 `test_and_set` 函数，它是原子的，只有一个线程能成功调用并将 `flag` 的状态原子地更改为设置 (`true`)，并返回它先前的值 (`false`)。此时，该线程成功获取了锁，退出循环。
 
-当 `flag` 对象的状态为设置 (`true`) 时，其线程调用 `test_and_set` 函数会返回 `true`，导致它们继续在循环中自旋，无法退出。直到先前持有锁的线程调用 `unlock()` 函数，将 `flag` 对象的状态原子地更改为清除 (`false`) 状态。此时，等待的线程中会有一个线程成功调用 `test_and_set` 返回 `false`，然后退出循环，成功获取锁。
+当 `flag` 对象的状态为设置 (`true`) 时，其它线程调用 `test_and_set` 函数会返回 `true`，导致它们继续在循环中自旋，无法退出。直到先前持有锁的线程调用 `unlock()` 函数，将 `flag` 对象的状态原子地更改为清除 (`false`) 状态。此时，等待的线程中会有一个线程成功调用 `test_and_set` 返回 `false`，然后退出循环，成功获取锁。
 
 > 值得注意的是，我们只是稍微的讲一下使用 `std::atomic_flag` 实现自旋锁。不过并不推荐各位在实践中使用它，具体可参见 [**Linus Torvalds**](https://en.wikipedia.org/wiki/Linus_Torvalds) 的[文章](https://www.realworldtech.com/forum/?threadid=189711&curpostid=189723)。其中有一段话说得很直接：
 >