更新不重要的文件。修改 std::thread 源码解析中的措辞。

Author: Mq-b

code/ModernCpp-ConcurrentProgramming-Tutorial/01-HelloWorld.cpp

@@ -1,5 +1,13 @@
 #include <iostream>
+#include <thread>
+#include <chrono>
 
-int main(){
+void hello(){
     std::cout << "Hello World" << std::endl;
+    // std::this_thread::sleep_for(std::chrono::seconds(5));
+}
+
+int main(){
+    std::thread t; // 默认构造？构造不关联线程的 thread 对象
+    std::cout <<std::boolalpha<< t.joinable() << '\n'; // false
 }

code/ModernCpp-ConcurrentProgramming-Tutorial/02-hardware_concurrency.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+#include <thread>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <vector>
+
+template<typename ForwardIt>
+auto sum(ForwardIt first, ForwardIt last) {
+    using value_type = std::iter_value_t<ForwardIt>;
+    std::size_t num_threads = std::thread::hardware_concurrency();
+    std::ptrdiff_t distance = std::distance(first, last);
+
+    if (distance > 1024000) {
+        // 计算每个线程处理的元素数量
+        std::size_t chunk_size = distance / num_threads;
+        std::size_t remainder = distance % num_threads;
+
+        // 存储每个线程的结果
+        std::vector<value_type> results{ num_threads };
+
+        // 存储关联线程的线程对象
+        std::vector<std::thread> threads;
+
+        // 创建并启动线程
+        auto start = first;
+        for (std::size_t i = 0; i < num_threads; ++i) {
+            auto end = std::next(start, chunk_size + (i < remainder ? 1 : 0));
+            threads.emplace_back([start, end, &results, i] {
+                results[i] = std::accumulate(start, end, value_type{});
+                });
+            start = end; // 开始迭代器不断向前
+        }
+
+        // 等待所有线程执行完毕
+        for (auto& thread : threads)
+            thread.join();
+
+        // 汇总线程的计算结果
+        value_type total_sum = std::accumulate(results.begin(), results.end(), value_type{});
+        return total_sum;
+    }
+
+    value_type total_sum = std::accumulate(first, last, value_type{});
+    return total_sum;
+}
+
+int main() {
+    std::vector<std::string> vecs{ "1","2","3","4" };
+    auto result = sum(vecs.begin(), vecs.end());
+    std::cout << result << '\n';
+
+    vecs.clear();
+    for (std::size_t i = 0; i <= 1024001u; ++i) {
+        vecs.push_back(std::to_string(i));
+    }
+    result = sum(vecs.begin(), vecs.end());
+    std::cout << result << '\n';
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/03-thread_management.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <thread>
+
+struct func {
+    int& m_i;
+    func(int& i) :m_i{ i } {}
+    void operator()(int n)const {
+        for (int i = 0; i <= n; ++i) {
+            m_i += i;           // 可能悬空引用
+        }
+    }
+};
+
+void f2() { throw std::runtime_error("test f2()"); }
+
+void f() {
+    int n = 0;
+    std::thread t{ func{n},10 };
+    try {
+        // todo.. 一些当前线程可能抛出异常的代码
+        f2();
+        t.join();
+    }
+    catch (...) {
+        t.join(); // 1
+        // 如果此处不抛出 会掩盖错误 我们根本没有处理 没有解决
+    }
+}
+
+int main() {
+    f();
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/04-RAII.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+#include <thread>
+#include <exception>
+
+struct func {
+    int& m_i;
+    func(int& i) :m_i{ i } {}
+    void operator()(int n)const {
+        for (int i = 0; i <= n; ++i) {
+            m_i += i;           // 可能悬空引用
+        }
+    }
+};
+
+void f2(){
+    // todo..
+    throw std::runtime_error("f2 error");
+}
+
+class thread_guard{
+public:
+    explicit thread_guard(std::thread& t) :thread_{ t }
+    {}
+    ~thread_guard(){
+        std::puts("析构");
+        if(thread_.joinable()){ // 如果当前有活跃线程 则进行 join
+            thread_.join();
+        }
+    }
+    thread_guard& operator=(const thread_guard&) = delete;
+    thread_guard(const thread_guard&) = delete;
+
+    std::thread& thread_;
+};
+
+void f() {
+    int n = 0;
+    std::thread t{ func{n},10 };
+    thread_guard g(t);
+    f2(); // 可能抛出异常
+}
+
+int main(){
+    // 栈回溯 
+    try{
+        f();
+    }catch (...){}
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/05-传递参数.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <thread>
+#include <functional>
+
+void f(const std::string&);
+
+void test() {
+    char buffer[1024]{};
+    //todo.. code
+    std::thread t{ f, std::string(buffer) }; // std::string(buffer) 构造对象，由 std::string 对象自行管理
+    t.detach();
+}
+
+int main(){
+    // A 的引用只能引用 A 类型，或者以任何形式 转换到 A
+    double a = 1;
+    const int& p = a; // a 隐式转换到了 int 类型，这个转换是纯右值表达式
+    // 因为 const T& 可以接右值表达式，所以才能通过编译
+    const std::string& s = "123"; // "123" 构造了 std::string 对象
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/06-this_thread命名空间.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <thread>
+#include <chrono>
+using namespace std::chrono_literals;
+
+int main() {
+    // 获取当前时间点
+    auto now = std::chrono::system_clock::now();
+
+    // 设置要等待的时间点为当前时间点之后的5秒
+    auto wakeup_time = now + 5s;
+
+    // 输出当前时间
+    auto now_time = std::chrono::system_clock::to_time_t(now);
+    std::cout << "Current time:\t\t" << std::put_time(std::localtime(&now_time), "%H:%M:%S") << std::endl;
+
+    // 输出等待的时间点
+    auto wakeup_time_time = std::chrono::system_clock::to_time_t(wakeup_time);
+    std::cout << "Waiting until:\t\t" << std::put_time(std::localtime(&wakeup_time_time), "%H:%M:%S") << std::endl;
+
+    // 等待到指定的时间点
+    std::this_thread::sleep_until(wakeup_time);
+
+    // 输出等待结束后的时间
+    now = std::chrono::system_clock::now();
+    now_time = std::chrono::system_clock::to_time_t(now);
+    std::cout << "Time after waiting:\t" << std::put_time(std::localtime(&now_time), "%H:%M:%S") << std::endl;
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/07-thread对象转移所有权.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+#include <thread>
+
+// https://github.com/Mq-b/Loser-HomeWork/discussions/206
+
+// 反直觉
+// 形参、实参
+// 函数调用传参，实际上是初始化了（构造）形参的对象
+
+void f(std::thread t) {
+    t.join();
+}
+
+int main() {
+    std::thread t{ [] {} };
+    f(std::move(t)); 
+    f(std::thread{ [] {} }); 
+}

code/ModernCpp-ConcurrentProgramming-Tutorial/08-thread构造源码解析.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include <thread>
+#include <type_traits>
+
+struct X {
+    X(X&& x)noexcept {}
+    template <class Fn, class... Args, std::enable_if_t<!std::is_same_v<std::remove_cvref_t<Fn>, X>, int> = 0>
+    X(Fn&& f, Args&&...args) {}
+    X(const X&) = delete;
+};
+
+int main(){
+    std::thread
+    X x{ [] {} };
+    X x2{ x }; // 选择到了有参构造函数，不导致编译错误
+}

md/详细分析/01thread的构造与源码解析.md

@@ -131,7 +131,7 @@ void _Start(_Fn&& _Fx, _Args&&... _Ax) {
 
 4. `constexpr auto _Invoker_proc = _Get_invoke<_Tuple>(make_index_sequence<1 + sizeof...(_Args)>{})`
 
-   - 调用 [`_Get_invoke`](https://github.com/microsoft/STL/blob/8e2d724cc1072b4052b14d8c5f81a830b8f1d8cb/stl/inc/thread#L65-L68) 函数，传入 `_Tuple` 类型和一个参数序列的索引序列（为了遍历形参包）。这个函数用于获取一个函数指针，指向了一个静态成员函数 [`_Invoke`](https://github.com/microsoft/STL/blob/8e2d724cc1072b4052b14d8c5f81a830b8f1d8cb/stl/inc/thread#L55-L63)，用来实际执行线程。这两个函数都非常的简单，我们来看看：
+   - 调用 [`_Get_invoke`](https://github.com/microsoft/STL/blob/8e2d724cc1072b4052b14d8c5f81a830b8f1d8cb/stl/inc/thread#L65-L68) 函数，传入 `_Tuple` 类型和一个参数序列的索引序列（为了遍历形参包）。这个函数用于获取一个函数指针，指向了一个静态成员函数 [`_Invoke`](https://github.com/microsoft/STL/blob/8e2d724cc1072b4052b14d8c5f81a830b8f1d8cb/stl/inc/thread#L55-L63)，它是线程实际执行的函数。这两个函数都非常的简单，我们来看看：
 
     ```cpp
      template <class _Tuple, size_t... _Indices>