C++11————线程库

🕗 发布于 2024-11-18 11:00 c++ 开发语言

thread 类的简单介绍

在 c++11 之前，涉及到多线程问题，都是和平台相关的，比如 windows 和 linux 下各自有自己的接口，这使得代码的可移植性比较差。在 c++11 中引入了线程库，使得 c++在编程时不需要依赖第三方库了

函数名	功能
thread()	构造一个线程对象，没有关联任何线程函数，即没有启动任何线程
thread(fn,args1,arrgs2, ...)	构造一个线程对象，并关联线程函数 fn，args1，args2， ... 为线程函数的参数
get_id()	获取线程 id
joinable()	线程是否还在执行，joinable 代表的是一个正在执行中的线程
join()	该函数调用后会阻塞线程，当该线程结束后，主线程继续执行
detach()	在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离的线程变成后台线程，创建线程的"死活"就与主线程无关

注意：

线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态
当创建一个线程对象后没有提供一个线程函数，该对象实际没有对应任何线程

#include <thread>
int main()
{
 std::thread t1;
 cout << t1.get_id() << endl;
 return 0;
}

当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行，线程函数一般情况下可以有三种方式启动：函数指针，lambda 表达式，函数对象

#include <iostream>
using namespace std;
#include <thread>
void ThreadFunc(int a)
{
 cout << "Thread1" << a << endl;
}
class TF
{
public:
 void operator()()
 {
 cout << "Thread3" << endl;
 }
};
int main()
{
    // 线程函数为函数指针
 thread t1(ThreadFunc, 10);
    
    // 线程函数为lambda表达式
 thread t2([]{cout << "Thread2" << endl; });
    
    // 线程函数为函数对象
    TF tf;
 thread t3(tf);
    
 t1.join();
 t2.join();
 t3.join();
 cout << "Main thread!" << endl;
 return 0;
}

线程类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，原线程对象失去对该线程的控制权，变成一个空线程，新线程对象获得该线程的控制权

#include <iostream>
#include <thread>
#include <chrono>

// 一个简单的函数，用于线程执行
void do_work(int id) {
    std::cout << "Thread " << id << " is working." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread " << id << " is done." << std::endl;
}

int main() {
    // 创建一个线程对象
    std::thread t1(do_work, 1); // t1 现在关联着一个执行 do_work(1) 的线程

    // 检查线程是否joinable，即是否有关联的线程
    if (t1.joinable()) {
        std::cout << "Thread t1 is joinable." << std::endl;
    }

    // 创建另一个线程对象，使用移动构造函数转移t1的线程控制权
    std::thread t2(std::move(t1)); // t1 现在是空的，t2 接管了原来 t1 的线程

    // 再次检查t1是否joinable，现在应该不是，因为它已经移动了
    if (t1.joinable()) {
        std::cout << "Thread t1 is joinable after move." << std::endl;
    } else {
        std::cout << "Thread t1 is not joinable after move." << std::endl;
    }

    // 等待t2关联的线程结束
    t2.join();

    // 尝试再次join t1，这将导致错误，因为t1不关联任何线程
    // t1.join(); // 这将抛出一个std::system_error异常

    return 0;
}

线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此，即使线程参数为引用类型，在线程中修改也不能修改外部实参，因为线程参数实际引用的是线程栈的拷贝，不是外部实参

如果想要通过形参改变外部实参时，必须借助 std::ref 函数

ref 就是把参数按照引用方式传递

#include <thread>
#include <iostream>
using namespace std;

void ThreadFunc1(int& x)
{
x += 10;
}
int main()
{
int a = 10;
// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际
//引用的是线程栈中的拷贝
thread t1(ThreadFunc1, a);
t1.join();
cout << a << endl;
// 如果想要通过形参改变外部实参时，必须借助std::ref()函数
thread t2(ThreadFunc1, std::ref(a));
t2.join();
cout << a << endl;
return 0;
}

原子性操作库(atomic)

多线程最主要的问题是共享数据带来的问题(即线程安全)，为此 C++11 中引入了原子操作：即不可被中断的一个或一系列操作，C++11 引入原子操作类型，使得线程间数据的同步变得非常高效

普遍的，我们可以使用 atomic 类模板，定义出需要的任意原子类型

atomic<T> t //声明一个类型为 T 的原子类型变量 t

#include <iostream>
using namespace std;
#include <thread>
#include <atomic>
atomic<size_t> sum=0;
void fun(size_t num)
{
for (size_t i = 0; i < num; ++i)
sum++;  // 原子操作
}
int main()
{
cout << "Before joining, sum = " << sum << std::endl;
thread t1(fun, 1000000);
thread t2(fun, 1000000);
t1.join();
t2.join();

cout << "After joining, sum = " << sum << std::endl;
return 0;
}

c++中的锁

C++11 标准库中<mutex>头文件提供了多种互斥锁类型，最常用的是 std::mutex

std::mutex mtx; // 声明一个互斥锁
mtx.lock(); // 锁定互斥锁
// 访问或修改共享数据
mtx.unlock(); // 解锁互斥锁

RAII 锁定

c++11 中引入了基于 RAII(资源获取即初始化)的锁定机制，lock_guard 和 unique_lock 是两种常用的 RAII 锁定器

lock_guard 在构造时，自动获取互斥锁，并在析构时自动释放互斥锁，适用于在一个作用域中加锁和解锁，构造线程安全的作用域

#include <mutex>
#include <iostream>

void critical_section(std::mutex& mtx) {
    std::lock_guard<std::mutex> lock(mtx); // 自动加锁
    // 临界区代码
    std::cout << "Critical section" << std::endl;
    // 离开作用域时自动解锁
}

int main() {
    std::mutex mtx;
    critical_section(mtx);
    return 0;
}

std::unique_lock 提供了对互斥锁的独占所有权，允许在构造时加锁，在析构时解锁，并且可以在对象生命周期中多次加锁和解锁

#include <mutex>
std::mutex mtx;
void function() {
    std::unique_lock<std::mutex> lock(mtx); // 构造时加锁
    // 临界区代码
    lock.unlock(); // 显式解锁
    // 非临界区代码
    lock.lock(); // 再次加锁
    // 临界区代码
} // 析构时解锁

condition_variable 条件变量

关于条件变量的一些函数

wait 函数

wait：使当前线程在条件变量上等待，直到被另一个线程唤醒

std::unique_lock<std::mutex> lock(mtx); // 获取互斥锁
cv.wait(lock);

在这个调用中，线程会释放锁并进入等待状态，当另一个线程调用 notify_one 或 notify_all 时，等待的线程会被唤醒，并尝试重新获取互斥锁

带谓词的 wait

cv.wait(lock, []{ return some_condition; });

允许你提供一个谓词(一个返回 bool 值的函数或者 labmda 表达式)，线程只有在谓词为真时才会被唤醒

notify_one 和 notify_all

cv.notify_one();//唤醒等待条件变量的一个线程
cv.notify_all();//唤醒等待条件变量的所有线程

原文地址：https://blog.csdn.net/soi55gshig/article/details/143839155

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：51单片机基础07 实时时钟-思路及代码参考1
下一篇：嵌入式开发人员如何选择合适的开源前端框架进行Web开发

预处理（1）（手绘）
大家好，今天给大家分享一下编译器预处理阶段，那么我们来看看。上面是一些预处理阶段的知识，那么明天给大家讲讲宏吧。
阅读更多2024-11-18
C语言项⽬实践-贪吃蛇
GetAsyncKeyState 的返回值是short类型，在上⼀次调⽤ GetAsyncKeyState 函数后，如果返回的16位的short数据中，最⾼位是1，说明按键的状态是按下，如果最⾼是0
阅读更多2024-11-18
Cache Line设计
以上代码实现了模拟的 Cache Line 结构，并包含了初始化、修改和释放内存的功能，完全符合题目中的需求描述。
阅读更多2024-11-18
Linux性能优化之火焰图简介
Linux 火焰图（Flame Graph）是一种可视化工具，用于分析程序性能问题，尤其是 CPU 使用情况。它展示了程序中函数调用的层次结构和各个调用栈占用的时间比例。本文详细介绍，包括火焰图的工作
阅读更多2024-11-18
南京邮电大学《智能控制技术》期末抢救（下）
专家系统是一个智能程序系统：具有相关领域内大量的专家知识；能应用人工智能技术模拟人类专家求解问题的思维过程进行推理，解决相关领域内的困难问题，并且达到领域专家的水平。专家系统所要解决的问题一般没有算法
阅读更多2024-11-18
pytorch基础-前向传播与反向传播
神经网络的基础，前向传播与反向传播（包含理论推导与pytorch代码）
阅读更多2024-11-18
【hacker送书第15期】AI绘画精讲与AIGC时代游戏美术设计：从入门到精通
随着人工智能技术的飞速发展，AI绘画已经成为了一个备受瞩目的领域。在这个背景下，北京大学出版社推出了一系列关于AI绘画的优秀图书，其中就包括了《AI绘画精讲：Stable Diffusion从入门到精
阅读更多2024-11-18
Electron：Menu 自定义菜单的使用、自定义右键菜单、动态创建菜单
Electron：Menu 自定义菜单的使用、自定义右键菜单、动态创建菜单
阅读更多2024-11-18
算法----二分法找出有序列表指定值
res = dichotomy(0, len(data) - 1, data, 56) # 这里max索引应该是len(data) - 1，因为索引从0开始。return dichotomy(mid
阅读更多2024-11-18
网络
第四次挥手时，客户端发出 ACK 后，会等待 2MSL（报文在网络上存在的最长时间）确保最后的 ACK 报文能够到达服务端，2MSL 之后客户端会关闭连接，服务端收到确认后也会关闭连接。IP 协议是整
阅读更多2024-11-18