更新视频代码以及CMake设置，引入三方库设置。

教案还未完成，先编写测试示例，后台播放音乐。

Author: Mq-b

.gitignore

@@ -41,6 +41,7 @@ node_modules/
 .vs/
 x64/
 out/
+bin/
 *.ilk
 *.pdb
 

code/ModernCpp-ConcurrentProgramming-Tutorial/21new和delete是线程安全的吗？.cpp

@@ -0,0 +1,26 @@
+#include <iostream>
+#include <thread>
+#include <mutex>
+
+struct X {
+    X(int v) { // 主要防止有人认为构造函数、析构函数啊，是线程安全的
+        std::cout << v << " 🤣\n";
+    }
+};
+
+void f() {
+    X* p = new X{ 1 }; // 存在数据竞争
+    delete p;
+}
+
+int main()
+{
+    for (int i = 0; i < 10; ++i) {
+        std::thread t{ f };
+        std::thread t2{ f };
+        t.join();
+        t2.join();
+    }
+
+    // C++ 保证的是内存的申请和释放 这种全局状态 是线程安全的
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/22线程存储期.cpp

@@ -0,0 +1,15 @@
+#include <iostream>
+#include <thread>
+
+int global_counter = 0;
+__declspec(thread) int thread_local_counter = 0;
+
+void print_counters() {
+    std::cout << "global：" << global_counter++ << '\n';
+    std::cout << "thread_local：" << thread_local_counter++ << '\n';
+}
+
+int main() {
+    std::thread{ print_counters }.join();
+    std::thread{ print_counters }.join();
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/23局部、全局、线程、CPU变量的对比与使用.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <thread>
+
+thread_local int n = (std::puts("thread_local init"), 0);
+
+void f(){
+    (void)n; // 防止 gcc 与 clang 优化
+    std::puts("f");
+}
+
+void f2(){
+    thread_local static int n = (std::puts("f2 init"), 0);
+}
+
+int main(){
+    (void)n; // 防止 gcc 与 clang 优化
+    std::cout << "main\n";
+    std::thread{ f }.join();
+    f2();
+    f2();
+    f2();
+}
+
+// gcc 与 clang 存在优化，会出现与 msvc 不同的结果，它们直接将线程变量优化掉了
+// 这应该视作 bug。
+// 视频中想到 std::async 是下一章的内容跳过了（想到的是 msvc 的一个问题），忘记了 gcc 与 clang 此处也存在问题。
+// https://godbolt.org/z/qa6YfMqP7

code/ModernCpp-ConcurrentProgramming-Tutorial/24等待事件或条件.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <thread>
+#include <condition_variable>
+#include <mutex>
+#include <chrono>
+using namespace std::chrono_literals;
+
+std::mutex mtx; // 互斥量
+std::condition_variable_any cv; // 条件变量
+bool arrived = false;
+
+void wait_for_arrival() {
+    std::unique_lock<std::mutex> lck(mtx); // 上锁
+    cv.wait(lck, [] { return arrived; }); // 等待 arrived 变为 true 会解锁的 再次上锁
+    std::cout << "到达目的地，可以下车了！" << std::endl;
+}
+
+void simulate_arrival() {
+    std::this_thread::sleep_for(std::chrono::seconds(5)); // 模拟地铁到站，假设5秒后到达目的地
+    {
+        std::lock_guard<std::mutex> lck(mtx);
+        arrived = true; // 设置条件变量为 true，表示到达目的地
+    }
+    cv.notify_one(); // 通知等待的线程
+}
+
+int main(){
+    std::thread t{ wait_for_arrival };
+    std::thread t2{ simulate_arrival };
+    t.join();
+    t2.join();
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/25线程安全的队列.cpp

@@ -0,0 +1,67 @@
+#include <iostream>
+#include <thread>
+#include <condition_variable>
+#include <mutex>
+#include <chrono>
+#include <queue>
+using namespace std::chrono_literals;
+
+template<typename T>
+class threadsafe_queue {
+    mutable std::mutex m;              // M&M 原则 互斥量，用于保护队列操作的独占访问
+    std::condition_variable data_cond; // 条件变量，用于在队列为空时等待
+    std::queue<T> data_queue;          // 实际存储数据的队列
+public:
+    threadsafe_queue() {}
+
+    void push(T new_value) {
+        {
+            std::lock_guard<std::mutex> lk{ m };
+            std::cout << "push:" << new_value << std::endl;
+            data_queue.push(new_value);
+        }
+        data_cond.notify_one();
+    }
+    // 从队列中弹出元素（阻塞直到队列不为空）
+    void pop(T& value) {
+        std::unique_lock<std::mutex> lk{ m };
+        data_cond.wait(lk, [this] {return !data_queue.empty(); }); // 解除阻塞 重新获取锁 lock
+        value = data_queue.front();
+        std::cout << "pop:" << value << std::endl;
+        data_queue.pop();
+    }
+    // 从队列中弹出元素（阻塞直到队列不为空），并返回一个指向弹出元素的 shared_ptr
+    std::shared_ptr<T> pop() {
+        std::unique_lock<std::mutex> lk{ m };
+        data_cond.wait(lk, [this] {return !data_queue.empty(); });
+        std::shared_ptr<T>res{ std::make_shared<T>(data_queue.front()) };
+        data_queue.pop();
+        return res;
+    }
+    bool empty()const {
+        std::lock_guard<std::mutex> lk(m);
+        return data_queue.empty();
+    }
+};
+
+void producer(threadsafe_queue<int>& q) {
+    for (int i = 0; i < 5; ++i) {
+        q.push(i);
+    }
+}
+void consumer(threadsafe_queue<int>& q) {
+    for (int i = 0; i < 5; ++i) {
+        int value{};
+        q.pop(value);
+    }
+}
+
+int main() {
+    threadsafe_queue<int> q;
+
+    std::thread producer_thread(producer, std::ref(q));
+    std::thread consumer_thread(consumer, std::ref(q));
+
+    producer_thread.join();
+    consumer_thread.join();
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/CMakeLists.txt

@@ -7,9 +7,19 @@ set(CMAKE_CXX_STANDARD 17)
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
 
 if(MSVC)
-    add_compile_options("/utf-8" "/permissive-" "/Zc:nrvo" "/Od")
+    add_compile_options("/utf-8" "/permissive-" "/Zc:nrvo")
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     add_compile_options("-finput-charset=UTF-8" "-fexec-charset=UTF-8")
 endif()
 
-add_executable(ModernCpp-ConcurrentProgramming-Tutorial "20recursive_mutex.cpp")
+add_executable(${PROJECT_NAME} "25线程安全的队列.cpp")
+
+
+# 设置 SFML 的 CMake 路径
+set(SFML_DIR "D:/lib/SFML-2.6.1-windows-vc17-64-bit/SFML-2.6.1/lib/cmake/SFML")
+
+# 查找 SFML 库并设置链接选项
+find_package(SFML 2.6.1 COMPONENTS system window graphics audio network REQUIRED)
+
+# 链接 SFML 库到项目
+target_link_libraries(${PROJECT_NAME} sfml-system sfml-window sfml-graphics sfml-audio sfml-network)

code/ModernCpp-ConcurrentProgramming-Tutorial/test.cpp

@@ -0,0 +1,25 @@
+#include "test/AduioPlayer.h"
+
+AudioPlayer audioPlayer;
+
+int main(){
+    audioPlayer.addAudioPath(AudioPlayer::soundResources[4]);
+    audioPlayer.addAudioPath(AudioPlayer::soundResources[5]);
+    audioPlayer.addAudioPath(AudioPlayer::soundResources[6]);
+    audioPlayer.addAudioPath(AudioPlayer::soundResources[7]);
+
+    std::thread t{ []{
+        std::this_thread::sleep_for(1s);
+        audioPlayer.addAudioPath(AudioPlayer::soundResources[1]);
+    } };
+    std::thread t2{ []{
+        audioPlayer.addAudioPath(AudioPlayer::soundResources[0]);
+    } };
+
+    std::cout << "乐\n";
+
+    t.join();
+    t2.join();
+
+    std::cout << "end\n";
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/test/AduioPlayer.h

@@ -0,0 +1,103 @@
+#ifndef AUDIOPLAYER_H
+#define AUDIOPLAYER_H
+
+#include <iostream>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+#include <string>
+#include <atomic>
+#include <array>
+#include <SFML/Audio.hpp>
+using namespace std::chrono_literals;
+
+class AudioPlayer {
+public:
+    AudioPlayer() : stop{ false }, player_thread{ &AudioPlayer::playMusic, this }
+    {}
+
+    ~AudioPlayer() {
+        // 等待队列中所有音乐播放完毕
+        while (!audio_queue.empty()) {
+            std::this_thread::sleep_for(50ms);
+        }
+        stop = true;
+        cond.notify_all();
+        if (player_thread.joinable()) {
+            player_thread.join();
+        }
+    }
+
+    void addAudioPath(const std::string& path) {
+        std::lock_guard<std::mutex> lock{ mtx };
+        audio_queue.push(path);
+        cond.notify_one();  // 通知线程新的音频
+    }
+
+private:
+    void playMusic() {
+        while (!stop) {
+            std::string path;
+            {
+                std::unique_lock<std::mutex> lock{ mtx };
+                cond.wait(lock, [this] { return !audio_queue.empty() || stop; });
+
+                if (audio_queue.empty()) return; // 防止在对象为空时析构出错
+
+                path = audio_queue.front();
+                audio_queue.pop();
+            }
+
+            if (!music.openFromFile(path)) {
+                std::cerr << "无法加载音频文件: " << path << std::endl;
+                continue;  // 继续播放下一个音频
+            }
+
+            music.play();
+
+            // 等待音频播放完毕
+            while (music.getStatus() == sf::SoundSource::Playing) {
+                sf::sleep(sf::seconds(0.1f));  // sleep 避免忙等占用CPU
+            }
+        }
+    }
+
+    std::atomic<bool> stop;
+    std::thread player_thread;
+    std::mutex mtx;
+    std::condition_variable cond;
+    std::queue<std::string> audio_queue;
+    sf::Music music;
+
+public:
+    static constexpr std::array soundResources{
+        "./sound/01初始化失败.ogg",
+        "./sound/02初始化成功.ogg",
+        "./sound/03试剂不足，请添加.ogg",
+        "./sound/04试剂已失效，请更新.ogg",
+        "./sound/05清洗液不足，请添加.ogg",
+        "./sound/06废液桶即将装满，请及时清空.ogg",
+        "./sound/07废料箱即将装满，请及时清空.ogg",
+        "./sound/08激发液A液不足，请添加.ogg",
+        "./sound/09激发液B液不足，请添加.ogg",
+        "./sound/10反应杯不足，请添加.ogg",
+        "./sound/11检测全部完成.ogg"
+    };
+    enum SoundIndex {
+        InitializationFailed,
+        InitializationSuccessful,
+        ReagentInsufficient,
+        ReagentExpired,
+        CleaningAgentInsufficient,
+        WasteBinAlmostFull,
+        WasteContainerAlmostFull,
+        LiquidAInsufficient,
+        LiquidBInsufficient,
+        ReactionCupInsufficient,
+        DetectionCompleted,
+        SoundCount // 总音频数量，用于计数
+    };
+};
+
+#endif // AUDIOPLAYER_H

md/04同步操作.md

@@ -1,6 +1,6 @@
 # 同步操作
 
-"同步操作"是指在计算机科学和信息技术中的一种操作方式，其中不同的任务或操作按顺序执行，一个操作完成后才能开始下一个操作。在多线程编程中，各个任务通常需要通过同步操作进行相互**协调和等待**，以确保数据的**一致性**和**正确性**。
+"同步操作"是指在计算机科学和信息技术中的一种操作方式，其中不同的任务或操作按顺序执行，一个操作完成后才能开始下一个操作。在多线程编程中，各个任务通常需要通过**同步设施**进行相互**协调和等待**，以确保数据的**一致性**和**正确性**。
 
 本章的主要内容有：
 
@@ -146,7 +146,7 @@ void wait(unique_lock<mutex>& _Lck, _Predicate _Pred) {
 
 ## 线程安全的队列
 
-在本节中，我们介绍了一个更为复杂的示例，以巩固我们对条件变量的学习。为了实现一个线程安全的队列，我们需要考虑以下两个关键点：
+在本节中，我们介将绍一个更为复杂的示例，以巩固我们对条件变量的学习。为了实现一个线程安全的队列，我们需要考虑以下两个关键点：
 
 1. 当执行 `push` 操作时，需要确保没有其他线程正在执行 `push` 或 `pop` 操作；同样，在执行 `pop` 操作时，也需要确保没有其他线程正在执行 `push` 或 `pop` 操作。
 
@@ -286,6 +286,8 @@ Consumer 线程弹出元素 4：
 
 到此，也就可以了。
 
+## 使用条件变量实现后台音乐播放
+
 ## 使用 `future`
 
 举个例子：我们在车站等车，你可能会做一些别的事情打发时间，比如学习[现代 C++ 模板教程](https://github.com/Mq-b/Modern-Cpp-templates-tutorial)、观看 [mq白](https://space.bilibili.com/1292761396) 的视频教程、玩手机等。不过，你始终在等待一件事情：***车到站***。