捕鲸叉的专栏

使用 std::mutex 保护共享数据是多线程编程中的重要技术，但需要注意保护数据太少或太多、死锁、持有锁时间太长等问题。通过合理的锁设计、固定的加锁顺序、细粒度锁、分批处理等措施，可以有效避免这些问题，提高多线程程序的性能和稳定性。

创建线程时传递参数给线程

在C++多线程编程中，线程的 joinable 属性是一个重要的概念，用于判断线程是否可以调用 join() 或 detach() 方法。当线程已经调用过 join() 或 detach() 之后，它将不再 joinable，此时调用 join() 或 detach() 会导致程序崩溃。在多线程程序中，如果主线程在等待子线程完成的过程中发生异常，需要确保子线程能够安全地被 join() 或 detach()，以避免资源泄露或未定义行为。通过这些技术，开发者可以确保多线程程序的健壮性和安全性。

在C++中，可以通过不同的方式来处理线程的等待、分离，以及异步获取执行结果

在C++中，线程函数和线程启动可以通过多种形式实现。使用 std::async 和 std::future 可以启动一个带返回值的线程函数。通过这些方法，开发者可以根据具体需求选择最合适的线程启动方式。Lambda 表达式提供了一种简洁的方式来定义线程函数。可以通过定义一个函数对象（Functor）来启动线程。线程函数可以接受参数，并将这些参数传递给线程函数。最基本的方式是使用函数指针来启动线程。线程函数和线程启动的几种不同形式。可以通过类的成员函数来启动线程。使用成员函数启动线程。使用带参数的线程函数。

C++并发编程的主要目的是任务隔离和提高性能。具体来说，可以总结为以下几点：任务隔离：通过并发编程，程序可以将不同的任务或计算分隔开，这样可以防止它们之间的相互干扰，提高程序的稳定性和可维护性。每个线程可以独立执行，减少了任务之间的耦合。提高性能：利用多核处理器的优势，C++并发编程可以实现更快的计算速度。通过并行处理，可以同时执行多个任务，充分利用CPU的资源，从而显著提高程序的性能。响应性：在需要处理大量输入或外部事件的应用程序（如图形用户界面或网络服务）中，并发编程可以提升响应性。

有依赖关系多个任务的并行处理一则

下面的代码展示了一个简单的线程池。#include <atomic>#include <functional>#include <iostream>#include <mutex>#include <queue>#include <thread>#include <vector>template<typename T>class thread_safe_queue{private:

使用feature特性，可以获得异步执行的效果。如下面的例子#include <iostream> #include <future> #include <chrono> #include <thread> int loopType (int from, int to) { for (int i = from; i != to; ++i) { std::cout <

使用mutex锁，设计一个线程安全的stack，示例如下#include <exception>#include <memory>#include <mutex>#include <stack>struct empty_stack : std::exception{ const char* what() const throw();};template<typename T>class threadsafe_sta

需要谨慎防止被保护的对象意外泄露到外界函数被更改状态。代码示例如下：#include <functional>#include <iostream>#include <mutex>#include <string>#include <thread>struct TData{public: int n; std::string str;public: TData() { n = 0; str = "Mout

在多线程开发中，常遇到共享数据需要保护的问题，我们可以使用互斥量std::mutext类来解决这个问题，示例如下#include <chrono>#include <iostream>#include <mutex>#include <thread>#include <vector>struct scoped_mutex{ scoped_mutex(std::mutex& mtx) : mt(mt

std::thread有一个get_id()函数可以唯一标识系统中线程。示例如下#include <chrono>#include <iostream>#include <string>#include <thread>#include <vector>std::thread::id master;void func(int i){ std::string msg = std::to_string(i);

我们可以动态计算并创建合理的线程数目， 代码示例如下#include <algorithm>#include <functional>#include <iostream>#include <numeric>#include <thread>#include <vector>template<typename Iterator, typename T>struct accumulate_block{

我们可以使用容器保存一组线程，如下面的vector装入一组线程：#include <chrono>#include <iostream>#include <string>#include <thread>#include <vector>void func(int n){ std::string str = std::to_string(n); str += '\n'; std::cout <&lt

线程scoped在某些场合还是很有用的，可以简化编程，不易出错。示例如下：#include <exception>#include <iostream>#include <thread>struct scoped_thread{ std::thread th; scoped_thread(std::thread&& t) { if (!t.joinable()) throw std::runtime_error("threa

线程对象可以和一般对象一样，其所有权可以被转移，示例如下：#include <iostream>#include <thread>void get(std::thread&& t){ t.detach(); int a; std::cin >> a; std::cout << a << std::endl;}void task(const char* sz){ std::cout << s

传递引用时需注意，如下面代码注释中所述：#include <iostream>#include <thread>void task(int& n){ n *= 2;}int main(){ int a = 100; //注意必须用std::ref绑定，否则由于thread构造函数无法识别，它将传入a的副本的引用给task函数 std::thread t(task, std::ref(a)); t.join()

我们可以对不同的多线程任务函数传递对应参数。其参考代码如下：#include <iostream>#include <thread>void task(int n, const char* message){ std::cout << n << "," << message << std::endl;}int main(){ std::thread t(task, 1, "something hap

包装类对象析构时执行线程#include <iostream>#include <thread>struct thread_guard{public: std::thread& t; explicit thread_guard(std::thread& _t) : t(_t) {}; ~thread_guard() { if(t.joinable()) t.join(); } thread_guard(thread_guard&

启动线程有detach()和join()两个函数，前者是异步启动，后者是同步启动并等待结束。#include <iostream>#include <thread>struct task{ int& i; task(int& i_) :i(i_) {}; void operator()() { for (int j = 0; j < 200; j++) std::cout

#include <iostream>#include <thread>void sayHello(){ std::cout << "Hello World!\n";}int main(){ std::thread t(sayHello); t.join(); return 0;}