三合一网站系统,乐平市建设局网站,网络优化这个行业怎么样,WordPress登录界面个性化C11下线程库 1. thread类的简单介绍2.线程函数参数3.原子性操作库(atomic)4.mutex的种类5. RAII风格加锁解锁5.1Lock_guard5.2unique_lock 6.condition_variable 1. thread类的简单介绍
在C11之前#xff0c;涉及到多线程问题#xff0c;都是和平台相关的#xff0c;比如wi… C11下线程库 1. thread类的简单介绍2.线程函数参数3.原子性操作库(atomic)4.mutex的种类5. RAII风格加锁解锁5.1Lock_guard5.2unique_lock 6.condition_variable 1. thread类的简单介绍
在C11之前涉及到多线程问题都是和平台相关的比如windows和linux下各有自己的接口这使得代码的可移植性比较差。C11中最重要的特性就是对线程进行支持了使得C在并行编程时不需要依赖第三方库而且在原子操作中还引入了原子类的概念。要使用标准库中的线程必须包含 thread 头文件。 C11中线程类
还有一些和线程有关的锁、条件变量、原子操作等。
C11线程库本质是对不同平台的线程库进行封装。
先看看线程相关主要的接口 函数名功能thread()构造一个线程对象没有关联任何线程函数即没有启动任何线程thread(fn,args1, args2,…)构造一个线程对象并关联线程函数fnargs1args2…为线程函数的参数get_id()获取线程idjionable()线程是否还在执行joinable代表的是一个正在执行中的线程。jion()该函数调用后会阻塞住线程当该线程结束后主线程继续执行detach()在创建线程对象后马上调用用于把被创建线程与线程对象分离开分离的线程变为后台线程创建的线程的死活就与主线程无关 线程不允许拷贝构造但支持移动构造。 也不允许赋值重载。但支持移动赋值。
注意 1.线程是操作系统中的一个概念线程对象可以关联一个线程用来控制线程以及获取线程的状态。 2.当创建一个线程对象后没有提供线程函数该对象实际没有对应任何线程。
int main()
{thread t1;return 0;
}3.当创建一个线程对象后并且给线程关联线程函数该线程就被启动与主线程一起运行。 线程函数一般情况下可按照以下三种方式提供
函数指针lambda表达式函数对象
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;
}还有在前面说过的创建线程池
int main()
{int n,m;cinnm;vectorthread v;v.resize(n);//调用thread默认构造函数,无参的//必须加引用,因为不加引用就是拷贝,而thread没有拷贝构造,只有移动构造for (auto t : v){//移动赋值t thread([m] {for (size_t i 0; i m; i){//这里想要把线程id打印出来,但是需要对象来调get_id();//但这里没有对象怎么办调用呢?//使用this_thread::get_id()cout this_thread::get_id() : i endl;}});}//这里主线程要join不然主线程结束了进程就结束了for (auto t : v){//阻塞等待t.join();}return 0;
}有好多东西是在线程的执行函数里面需要用到的但是没有线程对象可以用因此把这写东西写成全局的。所以把一些线程用到的公共的类放到这个命名空间里面 yield线程时间片还没有用完但让出时间片让其他线程先跑 sleep_until休眠到一个时间点 sleep_for休眠一个时间段如休眠3秒5秒
4.可以通过jionable()函数判断线程是否是有效的如果是以下任意情况则线程无效
采用无参构造函数构造的线程对象线程对象的状态已经转移给其他线程对象线程已经调用jion或者detach结束
问 1.进程和线程的区别 linux有说明
2.多进程域多线程的区别 linux有说明这里简单说一下 一个进程出现问题不会影响其他进程而一个线程出现问题因为线程就是在进程的地址空间运行的它出问题肯定就是进程出现了问题所以会导致整个进程退出。
3.并发与并行的区别 并行与并发是计算机领域中两个重要的概念它们描述了多任务处理的不同方式。 并行是指同时执行多个任务每个任务在不同的处理器上独立运行。在并行计算中多个任务可以同时进行从而提高系统的整体处理能力。并行计算通常需要具备多个处理器或者多核处理器来实现。 并发是指多个任务在同一时间段内交替执行通过时间片轮转等方式实现任务的切换。在并发计算中多个任务共享同一个处理器通过快速切换任务的执行来实现多任务的效果。并发计算通常适用于单个处理器或者单核处理器的情况。 简而言之区别在于并行是同时执行多个任务而并发是交替执行多个任务。
2.线程函数参数
线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的因此即使线程参数为引用类型在线程中修改后也不能修改外部实参因为其实际引用的是线程栈中的拷贝而不是外部实参。
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;
}注意如果是类成员函数作为线程参数时必须将this作为线程函数参数
3.原子性操作库(atomic)
多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的那么没问题因为只读操作不会影响到数据更不会涉及对数据的修改所以所有线程都会获得同样的数据。但是当一个或多个线程要修改共享数据时就会产生很多潜在的麻烦。比如
两个线程对共享变量进行可能会出现线程不安全的问题。
int val 0;void Func1(int n)
{for (size_t i 0; i n; i){val;}
}void Func2(int n)
{for (size_t i 0; i n; i){val;}
}int main()
{thread t1(Func1, 10000);thread t2(Func2, 20000);t1.join();t2.join();cout val endl;return 0;
}比较好的解决方法就是加锁。 #includemutexmutex mtx;
int val 0;void Func1(int n)
{for (size_t i 0; i n; i){mtx.lock();val;mtx.unlock();}
}void Func2(int n)
{for (size_t i 0; i n; i){mtx.lock();val;mtx.unlock();}
}int main()
{thread t1(Func1, 10000);thread t2(Func2, 20000);t1.join();t2.join();cout val endl;return 0;
}加锁之后就是线程安全的了。 这把锁加在里面好还是外面好呢这个等会在说先看下面的。两个线程能不能同时执行同一个函数会不会出现其他问题呢其实学过linux线程都知道是可以的。但为什么呢
#includemutexmutex mtx;
int val 0;void Func1(int n)
{for (size_t i 0; i n; i){mtx.lock();val;mtx.unlock();}
}int main()
{thread t1(Func1, 10000);thread t2(Func1, 20000);t1.join();t2.join();cout val endl;return 0;
}为什么两个线程可以执行同一个函数 因为这个函数编译好是放在代码段的两个线程都可以去代码段取这个函数。其次最重要的是每个线程都有独立的栈结构两个线程调用函数要建立自己的栈帧互不影响。你传的参数放在你的栈帧里它传的参数放在它的栈帧里。
回到上一个问题这个锁到底加在外面好还是里面好呢 对于在锁里的语句短且简单建议把锁加载外面因为锁频繁切换也要消耗资源。
void Func1(int n)
{mtx.lock();for (size_t i 0; i n; i){val;}mtx.unlock();
}另一种方式原子操作 原理很简单让变成原子操作。 原子操作都是由CAS提供的系统一般会提供CAS相关的接口。 CAS本质就是compare and swap 下面具体看一下原理看如何是变成原子操作的。 这里即使是同时也只有一个线程能够写回去。 对这里有兴趣的可以看看陈皓大佬的这篇文章。 无锁队列的实现
C线程库提供atomic就是对CAS以及刚才一系列东西的封装。 就比如最下面的对、- -、与、或、异或等这些操作都是原子的。 在C11中程序员不需要对原子类型变量进行加锁解锁操作线程能够对原子类型变量互斥的访问。 更为普遍的程序员可以使用atomic类模板定义出需要的任意原子类型。
atmoicT t; // 声明一个类型为T的原子类型变量t注意原子类型通常属于资源型数据多个线程只能访问单个原子类型的拷贝因此在C11中原子类型只能从其模板参数中进行构造不允许原子类型进行拷贝构造、移动构造以及operator等为了防止意外标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。
#include atomic
int main()
{atomicint a1(0);//atomicint a2(a1); // 编译失败atomicint a2(0);//a2 a1; // 编译失败return 0;
}把上面代码改成这种方式不仅不需要加锁而且也是并行运行的。
#includeatomicatomicint aval 0;void Func1(int n)
{ for (size_t i 0; i n; i){aval;}}int main()
{thread t1(Func1, 10000);thread t2(Func1, 20000);t1.join();t2.join();cout aval endl;return 0;
}刚才这种写法还有一些弊端实际写用不太建议写成全局的。 但是不用全局的也就不是共享资源了线程执行的函数又拿不到就不涉及线程安全的问题了这里就体现C11这里用lambda更好一些。给了lambda就可以定义局部的。因为lambda可以捕捉局部的变量就可以避免用全局的这样方式。
int main()
{atomicint aval 0;auto func [aval](int n) {for (size_t i 0; i n; i){aval;}};thread t1(func, 10000);thread t2(func, 20000);t1.join();t2.join();cout aval endl;return 0;
}4.mutex的种类
在C11中Mutex总共包了四个互斥量的种类
1.mutex
C11提供的最基本的互斥量该类的对象之间不能拷贝也不能进行移动。mutex最常用的三个函数
函数名函数功能lock()上锁锁住互斥量unlock()解锁释放对互斥量的所有权try_lock()尝试锁住互斥量如果互斥量被其他线程占有则当前线程也不会被阻塞 注意线程函数调用lock()时可能会发生以下三种情况
如果该互斥量当前没有被锁住则调用线程将该互斥量锁住直到调用 unlock之前该线程一直拥有该锁如果当前互斥量被其他线程锁住则当前的调用线程被阻塞住如果当前互斥量被当前调用线程锁住则会产生死锁(deadlock)
线程函数调用try_lock()时可能会发生以下三种情况
如果当前互斥量没有被其他线程占有则该线程锁住互斥量直到该线程调用 unlock 释放互斥量如果当前互斥量被其他线程锁住则当前调用线程返回 false而并不会被阻塞掉如果当前互斥量被当前调用线程锁住则会产生死锁(deadlock)
注意 互斥锁不能在递归里面用的递归里面玩互斥锁就可能死锁
2. recursive_mutex 递归互斥锁
其允许同一个线程对互斥量多次上锁即递归上锁来获得对互斥量对象的多层所有权释放互斥量时需要调用与该锁层次深度相同次数的unlock()除此之外recursive_mutex 的特性和mutex 大致相同。
原理注意并不是解锁之后再加锁万一有其他线程在等待解锁有可能其他线程抢到锁了然后运行但是并不希望是这样。锁的时候知道是那个线程获得这个锁的知道这个线程id等在递归时候看新来的线程跟获取锁的id是不是同一个如果是同一个就不在加锁直接走就可以了。
3.timed_mutex
比mutex多了两个成员函数try_lock_for()try_lock_until() 。 try_lock_for() 接受一个时间范围表示在这一段时间范围之内线程如果没有获得锁则被阻塞住与mutex 的 try_lock() 不同try_lock 如果被调用时没有获得锁则直接返回false如果在此期间其他线程释放了锁则该线程可以获得对互斥量的锁如果超时即在指定时间内还是没有获得锁则返回 false。 try_lock_until() 接受一个时间点作为参数在指定时间点未到来之前线程如果没有获得锁则被阻塞住如果在此期间其他线程释放了锁则该线程可以获得对互斥量的锁如果超时即在指定时间内还是没有获得锁则返回 false。
控制时间通常用下面这个类 int main()
{atomicint aval 0;auto func [aval](int n) {for (size_t i 0; i n; i){aval;this_thread::sleep_for(chrono::milliseconds(2000));cout aval endl;}};thread t1(func, 10000);thread t2(func, 20000);t1.join();t2.join();cout aval endl;return 0;
}4.recursive_timed_mutex 这个就不再细说。
5. RAII风格加锁解锁
5.1Lock_guard RAII风格加锁解锁 构造时加锁析构时解锁。
int main()
{atomicint aval 0;mutex mtx;auto func [aval,mtx](int n) {for (size_t i 0; i n; i){{//只在这个作用域加锁出了作用域就自动解锁//可以收到控制加锁范围lock_guardmutex lock(mtx);cout this_thread::get_id()- aval endl;}aval;}};thread t1(func, 10000);thread t2(func, 20000);t1.join();t2.join();cout aval endl;return 0;
}lock_guard的缺陷太单一用户没有办法对该锁进行控制因此C11又提供了unique_lock。
5.2unique_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所管理的互斥量的指针)。
6.condition_variable
写一个支持两个线程交替打印一个打印奇数一个打印偶数
// 支持两个线程交替打印t1一个打印奇数t2一个打印偶数,打印到100
int main()
{ int i 0;thread t1([] {while (i 100){if (i % 2){cout this_thread::get_id() - i endl;i;}}});thread t2([] {while (i 100){if (i % 2 0){cout this_thread::get_id() - i endl;i;}}});t1.join();t2.join();return 0;
}这个程序有些问题首先没有100。证明有个程序少跑了一次。可能i是99t1 if判断之后把i加到100然后t2在上去while判断不符合所有就没有打印出100。
那把t2线程while判断改成100能不能解决问题 是可以初步解决问题的。
int main()
{int i 0;thread t1([] {while (i 100){if (i % 2){cout this_thread::get_id() - i endl;i;}}});thread t2([] {while (i 100){if (i % 2 0){cout this_thread::get_id() - i endl;i;}}});t1.join();t2.join();return 0;
}这里真正的问题是效率不好。有这样的可能性。i为0 然后打印i在在然后t2时间片到了就切出去了但t1线程时间片没有到会一直在转因为i是1然后%2打印i然后ii变成2了。然后i一直是2一直在转不断的白判断浪费cpu资源。直到t2回来。
这里能不能你完了通知我我完了通知你。
加锁可不可以
int main()
{int i 0;mutex mtx;thread t1([] {while (i 100){mtx.lock();cout this_thread::get_id() - i endl;i;mtx.unlock();}});thread t2([] {while (i 100){mtx.lock();cout this_thread::get_id() - i endl;i;mtx.unlock(); }});t1.join();t2.join();return 0;
}可以看到光加锁并不能实现交替打印。 原因可能是其中一个线程竞争能力太强了解锁之后又成功加锁导致另一个线程一直在阻塞等待所以导致这个情况。
这里最好的方式就是使用环境变量。 wait就是等待notify就是通知。 条件变量并不是线程安全的需要和锁配合使用。 注意是unique_lock RAII风格的锁。 这个wait就和linux说过的一样 当线程阻塞了就会自动释放这个锁让其他线程去竞争这把锁一旦被唤醒就要重新申请到这个锁从这个wait返回就一定是拿到锁往下走。
#includecondition_variableint main()
{int i 0;mutex mtx;condition_variable cv;//奇数thread t1([] {while (i 100){unique_lockmutex lock(mtx);while (i % 2 0){cv.wait(lock);}cout t1: this_thread::get_id() - i endl;i;cv.notify_one();}});//偶数thread t2([] {while (i 100){unique_lockmutex lock(mtx);while (i % 2){cv.wait(lock);}cout t2: this_thread::get_id() - i endl;i;cv.notify_one();}});t1.join();t2.join();return 0;
}int main()
{int i 0;mutex mtx;condition_variable cv;bool flag true;//奇数 -- flag truethread t1([] {while (i 100){unique_lockmutex lock(mtx);while (flag true){cv.wait(lock);//阻塞}cout t1: this_thread::get_id() - i endl;i;flag true;cv.notify_one();}});//偶数 -- flag truethread t2([] {while (i 100){unique_lockmutex lock(mtx);while (flag false){cv.wait(lock);}cout t2: this_thread::get_id() - i endl;i;flag false;cv.notify_one();}});t1.join();t2.join();return 0;
}第二种wait方式 当pred返回false时才会阻塞。返回true不会阻塞。
int main()
{int i 0;mutex mtx;condition_variable cv;//奇数 -- flag truethread t1([] {while (i 100){unique_lockmutex lock(mtx);cv.wait(lock, [] {return i % 2; });//返回false被阻塞,true不被阻塞cout t1: this_thread::get_id() - i endl;i;cv.notify_one();}});//偶数 -- flag truethread t2([] {while (i 100){unique_lockmutex lock(mtx);cv.wait(lock, [] {return !(i % 2); });//返回false被阻塞,true不被阻塞cout t2: this_thread::get_id() - i endl;i;cv.notify_one();}});t1.join();t2.join();return 0;
}
