C++进阶 —— 线程库(C++11新特性)

十,线程库

thread类的简单介绍

在C++11之前涉及多线程问题,都是和平台相关的,如windows和Linux下各有自己的接口,这使代码的可移植性较差;C++11中最重要的特性就是对线程进行支持,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引用了原子类的概念;

要使用标准库中的线程,必须包含<thread>头文件;

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

 注:

  • 线程是操作系统的一个概念,线程对象可关联一个线程,用来控制线程以及获取线程的状态;
  • 当创建一个线程对象后,没有提供线程函数,该对象实际没有对应任何线程;
thread t;
cout << t.get_id() << endl;

get_id()返回类型为id,id类型实际为std::thread命名空间下封装的一个类;

  •  当创建一个线程对象后,并且给线程关联线程函数,该线程就被启动,与主线程一起运行;线程函数一般情况下可按照以下三种方式提供;
    • 函数指针
    • lambda表达式
    • 函数对象
#include <iostream>
#include <thread>
using namespace std;

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;
}
  • thread类是防拷贝的,不允许拷贝构造以及赋值,但可移动构造和移动赋值,即将一个线程对象关联线程的状态转移给其他线程对象,转移期间不意向线程的执行;
  • 可通过jionable()函数判断线程是否是有效的,如是以下任意情况则线程无效;
    • 采用无参构造函数构造的线程对象;
    • 线程对象的状态已经转移给其他线程对象了;
    • 线程已经调用jion或detach结束;

线程函数参数

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

注,如是类成员函数作为线程参数时,必须将this作为线程函数参数;

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

void ThreadFunc1(int& x)
{
	x += 10;
}
void ThreadFunc2(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;
	//地址的拷贝
	thread t3(ThreadFunc2, &a);
	t3.join();
	cout << a << endl;
	return 0;
}

jion与detach

启动了一个线程后,当这个线程结束的时候,thread库有两种方式回收线程使用的资源;

jion()

  • 主线程被阻塞,当新线程终止时,join()会清理相关的线程资源,然后返回,主线程再继续向下执行,然后销毁线程对象;由于jion()清理了线程的相关资源,thread对象与已销毁的线程就没有关系了,因此一个线程对象只能使用一次jion(),否则程序会崩溃;
//jion()的误用一
//如DoSomething()返回false主线程结束,jion()没有调用,线程资源没有回收,造成资源泄露
void ThreadFunc() { cout<<"ThreadFunc()"<<endl; }
bool DoSomething() { return false; }
int main()
{
 std::thread t(ThreadFunc);
 if(!DoSomething())
 return -1;

 t.join();
 return 0;
}
// jion()的误用二
void ThreadFunc() { cout<<"ThreadFunc()"<<endl; }
void Test1() { throw 1; }
void Test2()
{
 int* p = new int[10];
 std::thread t(ThreadFunc);
 try
 {
 Test1();
 }
 catch(...)
 {
 delete[] p;
 throw;
 }

 t.jion();
}
  • 因此采用jion()方式结束线程时,jion()的调用位置非常关键,为避免该问题,可采用RAII方式对线程对象进行封装;
#include <iostream>
#include <thread>
using namespace std;
class mythread
{
public:
    explicit mythread(std::thread& t)
        :m_t(t)
    {}
    ~mythread()
    {
        if (m_t.joinable())
            m_t.join();
    }
    mythread(mythread const&) = delete;
    mythread& operator=(const mythread&) = delete;
private:
    std::thread& m_t;
};

void ThreadFunc() { cout << "ThreadFunc()" << endl; }
bool DoSomething() { return false; }

int main()
{
    thread t(ThreadFunc);
    mythread q(t);
    if (DoSomething())
        return -1;
    return 0;
}

detach()方式

  • 该函数被调用后,新线程与线程对象分离,不再被线程对象所表达,就不能通过线程对象控制线程了,新线程会在后台运行,其所有权和控制权将会给C++运行库;同时C++运行库保证,当线程退出时,其相关资源能够正确回收;
  • detach()函数一般在线程对象创建好后就调用,因为如不是jion()等待方式结束,那么线程对象可能会在新线程结束之前被销毁而导致程序崩溃;因为std::thread的析构函数中,如线程的状态是jionable,std::terminate将会被调用,而terminate()函数直接会终止程序;
  • 因此线程对象销毁前,要么以jion()的方式等待线程结束,要么以detach()的方式将线程对象分离;

原子性操作库(atomic)

多线程最主要的问题是共享数据带来的问题(即线程安全);如共享数据都是只读,没有问题,因为只读操作不会影响到数据,更不会涉及对数据的修改,所以所有线程都会获得同样的数据;但当一个或多个线程要修改共享数据时,就会产生潜在的麻烦;

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

unsigned long sum = 0L;
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, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;
	return 0;
}

C++98传统的解决方式,对共享修改的数据可加锁保护;

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

std::mutex m;
unsigned long sum = 0L;
void fun(size_t num)
{
	for (size_t i = 0; i < num; ++i)
	{
		m.lock();
		sum++;
		m.unlock();
	}
}

int main()
{
	cout << "Before joining,sum = " << sum << std::endl;
	thread t1(fun, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;
	return 0;
}

虽然加锁可以解决,但加锁有一个缺陷,就是只要一个线程在对sum++是,其他线程就会被阻塞,会影响程序运行效率,而且锁如果控制不好,容易造成死锁;

因此C++11引入了原子操作,即不可被中断的一个或一系列操作,C++11引入的原子操作类型,使得线程间数据的同步变得非常高效;需要使用以上原子操作变量时,必须添加头文件;

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

atomic_long 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++11中,程序员不需要对原子类型变量进行加锁解锁操作,线程能够对原子类型变量互斥访问;可以使用atomic类模板,定义出需要的任意原子类型;

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

注,原子类型通常属于“资源型”数据,多个数据只能访问单个原子类型的拷贝,因此C++11中原子类型只能从其他模板参数中进行构造,不允许原子类型进行拷贝构造、移动构造以及operator=等,为了防止意外,标准库已经将atomic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除了;

lock_guard与unique_lock

在多线程环境下,如想要保证某个变量的安全性,只要将其设置成对应的原子类型即可,即高效又不容易出现死锁问题,但有些情况下,可能需要保证一段代码的安全性,那么就只能通过死锁的方式进行控制了;

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

int number = 0;
mutex g_lock;
int ThreadProc1()
{
	for (int i = 0; i < 100; i++)
	{
		g_lock.lock();
		++number;
		cout << "thread 1 :" << number << endl;
		g_lock.unlock();
	}
	return 0;
}
int ThreadProc2()
{
	for (int i = 0; i < 100; i++)
	{
		g_lock.lock();
		--number;
		cout << "thread 2 :" << number << endl;
		g_lock.unlock();
	}
	return 0;
}
int main()
{
	thread t1(ThreadProc1);
	thread t2(ThreadProc2);
	t1.join();
	t2.join();
	cout << "number:" << number << endl;
	system("pause");
	return 0;
}

上述代码的缺陷是锁控制不好可能会造成死锁,最常见的比如在锁中间代码返回,或在锁的范围内抛异常;因此C++11采用RAII的方式对锁进行了封装,即lock_guard和unique_lock;

mutex的种类

C++11中,mutex总共四个互斥量的种类;

std::mutex

  • C++11提供的最基本的互斥量,该类的对象之间不能拷贝,也不能进行移动;
  • 最常见三个函数
    • lock(),上锁,锁住互斥量;
    • unlock(),解锁,释放对互斥量的所有权;
    • try_lock(),尝试锁住互斥量,如互斥量被其他线程占用,则当前线程也不会被阻塞;

线程函数调用lock()时,可能会发生以下三种情况

  • 如该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用unlock之前,该线程一直拥有该锁;
  • 如当前互斥量被其他前程锁住,则当前的调用线程被阻塞;
  • 如当前互斥量被当前调用线程锁住,则会产生死锁;

线程函数调用try_lock()时,可能会发生以下三种情况

  • 如当前互斥量没有被其他线程占有,则该线程锁住互斥量,直到该线程调用unlock释放互斥量;
  • 如当前互斥量被其他线程锁住,则当前调用线程返回false,并不会被阻塞掉;
  • 如当前互斥量被当前调用线程锁住,则会产生死锁;

std::recursive_mutex

  • 允许同一个线程对互斥量多次上锁(即递归上锁),来获得对互斥量对象的多层所有权,释放互斥量时需要调用与该锁层次深度相同次数的unlock(),除此之外,与std::mutex大致相同;

std::timed_mutex

  • 比std::mutex多了两个成员函数,try_lock_for(),try_lock_until();

try_lock_for()

  • 接受一个时间范围,表示在这一段时间范围内,线程如没有获得锁则被阻塞(与std::mutex的try_lock()不同,try_lock如被调用时没有获得锁则直接返回false),如在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如超时(即在指定时间内还是没有获得锁),则返回false;

try_lock_until()

  • 接受一个时间点作为参数,在指定时间点未到来之前线程如没有获得锁则被阻塞,如在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如超时(即在指定时间内还是没有获得锁),则返回false;

std::recursive_timed_mutex

lock_guard

std::lock_guard是C++11中定义的模板类;

template<class _Mutex>
class lock_guard
{
public:
	// 在构造lock_gard时,_Mtx还没有被上锁
	explicit lock_guard(_Mutex& _Mtx)
		: _MyMutex(_Mtx)
	{
		_MyMutex.lock();
	}
	// 在构造lock_gard时,_Mtx已经被上锁,此处不需要再上锁
	lock_guard(_Mutex& _Mtx, adopt_lock_t)
		: _MyMutex(_Mtx)
	{}
	~lock_guard() _NOEXCEPT
	{
		_MyMutex.unlock();
	}
	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
private:
	_Mutex& _MyMutex;
};

lock_guard类模板主要是通过RAII的方式,对其管理的互斥量进行了封装,在需要加锁的地方,只需要用上述介绍的任意互斥体实例化一个lock_guard,调用构造函数成功上锁,出作用域前,lock_guard对象要被销毁,调用析构函数自动解锁,可以有效避免死锁问题。

unique_lock

与lock_gard类似,unique_lock类模板也是采用RAII的方式对锁进行了封装,并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作,即其对象之间不能发生拷贝。

在构造(或移动(move)赋值)时, unique_lock 对象需要传递一个Mutex对象作为它的参数,新创建的unique_lock对象负责传入的Mutex对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时,自动调用构造函数上锁, unique_lock对象销毁时自动调用析构函数解锁,可以很方便的防止死锁问题。

与lock_guard不同的是,unique_lock更加的灵活,提供了更多的成员函数:

  • 上锁/解锁操作:lock、try_lock、try_lock_for、try_lock_until和unlock
  • 修改操作:移动赋值、交换(swap:与另一个unique_lock对象互换所管理的互斥量所有权)、释放 (release:返回它所管理的互斥量对象的指针,并释放所有权)
  • 获取属性:owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、 mutex(返回当前unique_lock所管理的互斥量的指针)。

lock_guard/unique_lock详解

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mfbz.cn/a/25160.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Axure教程—水平方向多色图(中继器)

本文将教大家如何用AXURE制作动态水平方向多色图 一、效果介绍 如图&#xff1a; 预览地址&#xff1a;https://l83ucp.axshare.com 下载地址&#xff1a;https://download.csdn.net/download/weixin_43516258/87822666 二、功能介绍 简单填写中继器内容即可生成动态水平多色…

Linux-模拟一个简单的shell

什么是shell外壳&#xff1f;就是操作系统给我们的一个命令行解释器&#xff0c;在Linux系统中&#xff0c;它的shell叫做bash。 那么bash本质是什么呢&#xff1f; 本质就是一个文件&#xff0c;一个进程。 万物皆文件 每个操作系统的shell都是很复杂的&#xff0c;想要…

【Matter】使用chip tool在ESP32-C3上进行matter开发

文章目录 使用chip tool在ESP32-C3上进行matter开发前提准备编译 chip-tool1.激活esp-matter环境2.编译matter所需环境3.构建CHIP TOOL chip-tool client 调试设备说明1.基于 BLE 调试2.通过IP与设备配对3.Trust store4.忘记当前委托的设备 使用chip-tool点灯1.matter环境激活2…

linuxOPS基础_Linux系统的文件目录结构及用途

linux系统文件目录结构 Linux 系统不同于 Windows&#xff0c;没有 C 盘、D 盘、E 盘那么多的盘符&#xff0c;只有一个根目录&#xff08;/&#xff09;&#xff0c;所有的文件&#xff08;资源&#xff09;都存储在以根目录&#xff08;/&#xff09;为树根的树形目录结构中…

【大数据之Hive】四、配置Hive元数据存储到MySQL

需求&#xff1a;   把Hive元数据写道MySQL的metastore数据库中&#xff08;MySQL默认没有metastore数据库&#xff0c;需要提前创建&#xff1a;create database metastore;&#xff09;   连接地址&#xff1a;jdbc:mysql//hadoop102:3306/metastore   驱动&#xff1a…

什么是SOAP

什么是SOAP 什么是SOAP? SOAP (Simple Object Access Protocol) 是一种基于XML的通信协议&#xff0c;用于在网络上交换结构化的信息。它被广泛用于分布式系统中的应用程序间通信。 SOAP定义了一组规范&#xff0c;描述了消息的格式、通信的方式和处理消息的过程。它允许应…

第四章 程序的控制结构

文章目录 第四章 程序的控制结构4.1 程序的三种控制结构4.1.1 程序流程图4.1.2 程序控制结构基础4.1.3 程序控制结构扩展 4.2 程序的多分支结构4.2.1 单分支结构&#xff1a;if4.2.2 二分支结构&#xff1a;if-else4.2.3 多分支结构&#xff1a;if-elif-else4.2.4 判断条件及组…

图及其与图相关的算法

⭐️前言⭐️ 本篇文章主要介绍图及其与图相关的算法 &#x1f349;欢迎点赞 &#x1f44d; 收藏 ⭐留言评论 &#x1f4dd;私信必回哟&#x1f601; &#x1f349;博主将持续更新学习记录收获&#xff0c;友友们有任何问题可以在评论区留言 &#x1f349;博客中涉及源码及博主…

智慧档案馆八防是怎么建设的?都需要注意哪些内容

智慧档案馆八防环境监控系统一体化解决系统方案 智慧档案库房一体化平台通过智慧档案管理&#xff0c;实现智慧档案感知协同处置功能&#xff1b;实现对档案实体的智能化识别、定位、跟踪监控&#xff1b;实现对档案至智能密集架、空气恒湿净化一体设备、安防设备&#xff0c…

Linux守护进程

守护进程 Linux/Unix 会话 会话首进程 进程组 组长进程&#xff1a;第一个启动的进程叫组长进程。 关闭终端&#xff1a;进程组里全部进程关闭。 setsid()创建一个新的会话。&#xff08;必须是组员进程才可以创建一个新的会话&#xff09; 1.先fork()&#xff0c;退出父进程 2…

电力系统的虚假数据注入攻击和MTD系统研究(Matlab代码实现)

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…

字符串最后一个单词的长度

描述 计算字符串最后一个单词的长度&#xff0c;单词以空格隔开&#xff0c;字符串长度小于5000。&#xff08;注&#xff1a;字符串末尾不以空格为结尾&#xff09; 输入描述&#xff1a; 输入一行&#xff0c;代表要计算的字符串&#xff0c;非空&#xff0c;长度小于500…

mysql触发器监听数据投递中间件

目前市面上有许多的 CDC&#xff08;Change Data Capture&#xff09; 框架用于监听数据库的数据变动&#xff0c;例如&#xff1a;canal、Debezium、Maxwell等都是用来解析 binlog 日志实现事件的监听。但是有一个情况就是如果公司对 binlog 日志文件的权限管控的很严格&#…

【学习日记2023.6.2】之 管理端报表统计

文章目录 11. 管理端报表统计11.1 Apache ECharts11.1.1 介绍11.1.2 入门案例 11.2 营业额统计11.2.1 需求分析和设计11.2.2 代码开发Controller层Service层接口Service层实现类Mapper层 11.2.3 功能测试11.2.4 提交代码 11.3 用户统计11.3.1 需求分析和设计11.3.2 代码开发Con…

如何编写接口自动化框架系列通过yaml来管理测试用例(四)

本文是接口自动化测试框架系列篇的第四篇 &#xff0c;主要介绍yaml包的使用 。自动化测试的本质是将功能测试用例交给代码去 目录 1. yaml介绍&#xff1f; 2.python中的yaml包 3.项目中使用yaml包 4 项目总结 执行 &#xff0c;测试人员往往是在自动化框架添加对应的测试…

排查Javascript内存泄漏案例(一)

Chrome DevTools里的Performance面板和Memory面板可以用来定位内存问题。 如何判断应用发生内存泄漏&#xff1f; 为了证明螃蟹的听觉在腿上&#xff0c;一个专家捉了只螃蟹并冲它大吼&#xff0c;螃蟹很快就跑了。然后捉回来再冲它吼&#xff0c;螃蟹又跑了。最后专家把螃蟹的…

WPS 借助 ML Kit 无缝翻译 43 种语言,每年净省 6,500 万美元

△ 动画说明: 在笔记本电脑屏幕中&#xff0c;汉字 "文" 将变为字母 "A"&#xff0c;代表文本的横线将逐一出现&#xff0c;就像有人在输入内容一样。 WPS 是一款办公套件软件&#xff0c;可让用户轻松查看和编辑其所有文档、演示文稿、电子表格等。作为一…

RK3568 AP6275S蓝牙驱动程序调度过程

1、前言 今年3月份调度了RK3568驱动程序&#xff0c;当时由于时间的问题&#xff0c;AP6275S蓝牙驱动程序没有调试成功。当时仔细检查的设备树的配置。 wireless_bluetooth: wireless-bluetooth {compatible "bluetooth-platdata";clocks <&rk809 1>;cl…

JavaCV - 图像暗通道去雾

一、效果图 二、实现原理 暗通道先验:首先说在绝大多数非天空的局部区域里,某一些像素总会有至少一个颜色通道具有很低的值,也就是说该区域光强是一个很小的值。所以给暗通道下了个数学定义,对于任何输入的图像J,其暗通道可以用下面的公式来表示:其中JC表示彩色图像每个…

【Vue2.0源码学习】虚拟DOM篇-Vue中的DOM-优化更新子节点

1. 前言 在上一篇文章中&#xff0c;我们介绍了当新的VNode与旧的oldVNode都是元素节点并且都包含子节点时&#xff0c;Vue对子节点是 先外层循环newChildren数组&#xff0c;再内层循环oldChildren数组&#xff0c;每循环外层newChildren数组里的一个子节点&#xff0c;就去…
最新文章