建设银行考试报名网站wordpress开源社区

建设银行考试报名网站,wordpress开源社区,在线网站seo诊断,北京网页设计公司就找兴田德润mutex又称互斥量#xff0c;C 11中与 mutex相关的类#xff08;包括锁类型#xff09;和函数都声明在 头文件中#xff0c;所以如果 你需要使用 std::mutex#xff0c;就必须包含头文件。 C11提供如下4种语义的互斥量#xff08;mutex#xff09; std::mutex#xff0…mutex又称互斥量C 11中与 mutex相关的类包括锁类型和函数都声明在 头文件中所以如果 你需要使用 std::mutex就必须包含头文件。C11提供如下4种语义的互斥量mutexstd::mutex独占的互斥量不能递归使用。std::time_mutex带超时的独占互斥量不能递归使用。std::recursive_mutex递归互斥量不带超时功能。std::recursive_timed_mutex带超时的递归互斥量。1.2.1 独占互斥量std::mutexstd::mutex 介绍下面以 std::mutex 为例介绍 C11 中的互斥量用法。std::mutex 是C11 中最基本的互斥量std::mutex 对象提供了独占所有权的特性——即不支持递归地 对 std::mutex 对象上锁而 std::recursive_lock 则可以递归地对互斥量对象上锁。std::mutex 的成员函数构造函数std::mutex不允许拷贝构造也不允许 move 拷贝最初产生的 mutex 对象是处于 unlocked 状态的。lock()调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况(1). 如果该互斥量当前没 有被锁住则调用线程将该互斥量锁住直到调用 unlock之前该线程一直拥有该锁。(2). 如果当 前互斥量被其他线程锁住则当前的调用线程被阻塞住。(3). 如果当前互斥量被当前调用线程锁 住则会产生死锁(deadlock)。unlock() 解锁释放对互斥量的所有权。try_lock()尝试锁住互斥量如果互斥量被其他线程占有则当前线程也不会被阻塞。线程调用该 函数也会出现下面 3 种情况(1). 如果当前互斥量没有被其他线程占有则该线程锁住互斥量直 到该线程调用 unlock 释放互斥量。(2). 如果当前互斥量被其他线程锁住则当前调用线程返回 false而并不会被阻塞掉。(3). 如果当前互斥量被当前调用线程锁住则会产生死锁(deadlock)。范例1-2-mutex1//1-2-mutex1 #include iostream // std::cout #include thread // std::thread #include mutex // std::mutex volatile int counter(0); // non-atomic counter std::mutex mtx; // locks access to counter void increases_10k() { for (int i0; i10000; i) { // 1. 使用try_lock的情况 // if (mtx.try_lock()) { // only increase if currently not locked: // counter; // mtx.unlock(); // } // 2. 使用lock的情况 { mtx.lock(); counter; mtx.unlock(); } } } int main() { std::thread threads[10]; for (int i0; i10; i) threads[i] std::thread(increases_10k); for (auto th : threads) th.join(); std::cout successful increases of the counter counter std::endl; return 0; }1.2.2 递归互斥量std::recursive_mutex递归锁允许同一个线程多次获取该互斥锁可以用来解决同一线程需要多次获取互斥量时死锁的问题。死锁范例1-2-mutex2-dead-lock//死锁范例1-2-mutex2-dead-lock #include iostream #include thread #include mutex struct Complex { std::mutex mutex; int i; Complex() : i(0){} void mul(int x) { std::lock_guardstd::mutex lock(mutex); i * x; } void div(int x) { std::lock_guardstd::mutex lock(mutex); i / x; } void both(int x, int y) { //lock_guard 构造函数加锁 析构函数释放锁 std::lock_guardstd::mutex lock(mutex); mul(x); // 获取不了锁 div(y); } void init() { //lock_guard 构造函数加锁 析构函数释放锁 std::lock_guardstd::mutex lock(mutex); sub_init(); } void sub_init() { std::lock_guardstd::mutex lock(mutex); } }; int main(void) { Complex complex; complex.both(32, 23); std::cout main finish\n; return 0; }运行后出现死锁的情况。在调用both时获取了互斥量在调用mul时又要获取互斥量但both的并没有 释放从而产生死锁。使用递归锁//递归锁1-2-recursive_mutex1 #include iostream #include thread #include mutex struct Complex { std::recursive_mutex mutex; int i; Complex() : i(0){} void mul(int x) { std::lock_guardstd::recursive_mutex lock(mutex); i * x; } void div(int x) { std::unique_lockstd::recursive_mutex lock(mutex); i / x; } void both(int x, int y) { std::lock_guardstd::recursive_mutex lock(mutex); mul(x); div(y); } }; int main(void) { Complex complex; complex.both(32, 23); //因为同一线程可以多次获取同一互斥量不会发生死锁 std::cout main finish\n; return 0; }虽然递归锁能解决这种情况的死锁问题但是尽量不要使用递归锁主要原因如下1. 需要用到递归锁的多线程互斥处理本身就是可以简化的允许递归很容易放纵复杂逻辑的产生并 且产生晦涩当要使用递归锁的时候应该重新审视自己的代码是否一定要使用递归锁2. 递归锁比起非递归锁效率会低3. 递归锁虽然允许同一个线程多次获得同一个互斥量但可重复获得的最大次数并未具体说明一旦 超过一定的次数再对lock进行调用就会抛出std::system错误。1.2.3 带超时的互斥量std::timed_mutex和 std::recursive_timed_mutexstd::timed_mutex比std::mutex多了两个超时获取锁的接口try_lock_for和try_lock_until//1-2-timed_mutex #include iostream #include thread #include mutex #include chrono std::timed_mutex mutex; void work() { std::chrono::milliseconds timeout(100); while (true) { if (mutex.try_lock_for(timeout)) { std::cout std::this_thread::get_id() : do work with the mutex std::endl; std::chrono::milliseconds sleepDuration(250); std::this_thread::sleep_for(sleepDuration); mutex.unlock(); std::this_thread::sleep_for(sleepDuration); } else { std::cout std::this_thread::get_id() : do work without the mutex std::endl; std::chrono::milliseconds sleepDuration(100); std::this_thread::sleep_for(sleepDuration); } } } int main(void) { std::thread t1(work); std::thread t2(work); t1.join(); t2.join(); std::cout main finish\n; return 0; }1.2.4 lock_guard和unique_lock的使用和区别相对于手动lock和unlock我们可以使用RAII(通过类的构造析构)来实现更好的编码方式。RAII也称为“资源获取就是初始化”是c等编程语言常用的管理资源、避免内存泄露的方法。它保证 在任何情况下使用对象时先构造对象最后析构对象。1 unique_lock,lock_guard的使用这里涉及到unique_lock,lock_guard的使用。范例1-2-4-lock#include iostream // std::cout #include thread // std::thread #include mutex // std::mutex, std::lock_guard #include stdexcept // std::logic_error std::mutex mtx; void print_even (int x) { if (x%20) std::cout x is even\n; else throw (std::logic_error(not even)); } void print_thread_id (int id) { try { // 这里的lock_guard换成unique_lock是一样的。 // using a local lock_guard to lock mtx guarantees unlocking on destruction / exception: // std::lock_guardstd::mutex lck (mtx); std::unique_lockstd::mutex lck (mtx); print_even(id); } catch (std::logic_error) { std::cout [exception caught]\n; } } int main () { std::thread threads[10]; // spawn 10 threads: for (int i0; i10; i) threads[i] std::thread(print_thread_id,i1); for (auto th : threads) th.join(); return 0; }这里的lock_guard换成unique_lock是一样的。2 unique_lock,lock_guard的区别unique_lock与lock_guard都能实现自动加锁和解锁但是前者更加灵活能实现更多的功能。unique_lock可以进行临时解锁和再上锁如在构造对象之后使用lck.unlock()就可以进行解锁 lck.lock()进行上锁而不必等到析构时自动解锁。#include iostream #include deque #include thread #include mutex #include condition_variable #include unistd.h std::dequeint q; std::mutex mu; std::condition_variable cond; int count 0; void fun1() { while (true) { { std::unique_lockstd::mutex locker(mu); // 能否换成lock_guard lock std::cout fun1 lock\n; q.push_front(count); // locker.unlock(); // 这里是不是必须的 lock_guard是没有手动释放锁的 unlock cond.notify_one(); //condition_variable 条件和Linux条件变量一样的 } sleep(1); } } void fun2() { while (true) { std::unique_lockstd::mutex locker(mu); std::cout fun2 lock\n; std::cout fun2 wait into\n; cond.wait(locker, [](){return !q.empty();}); std::cout fun2 wait leave\n; auto data q.back(); q.pop_back(); // locker.unlock(); // 这里是不是必须的 std::cout thread2 get value form thread1: data std::endl; } } int main() { std::thread t1(fun1); std::thread t2(fun2); t1.join(); t2.join(); return 0; }条件变量的目的就是为了在没有获得某种提醒时长时间休眠; 如果正常情况下, 我们需要一直循环 (sleep), 这样的问题就是CPU消耗时延问题条件变量的意思是在cond.wait这里一直休眠直到 cond.notify_one唤醒才开始执行下一句; 还有cond.notify_all()接口用于唤醒所有等待的线程。那么为什么必须使用unique_lock呢?原因: 条件变量在wait时会进行unlock再进入休眠, lock_guard并无该操作接口wait:如果线程被唤醒或者超时那么会先进行lock获取锁, 再判断条件(传入的参数)是否成立, 如果成立则 wait函数返回否则释放锁继续休眠notify:进行notify动作并不需要获取锁使用场景需要结合notifywait的场景使用unique_lock 如果只是单纯的互斥使用lock_guard3 总结lock_guard1.std::lock_guard 在构造函数中进行加锁析构函数中进行解锁。2.锁在多线程编程中使用较多因此c11提供了lock_guard模板类在实际编程中我们也可以根 据自己的场景编写resource_guard RAII类避免忘掉释放资源。std::unique_lock1. unique_lock 是通用互斥包装器允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与 条件变量一同使用。2. unique_lock比lock_guard使用更加灵活功能更加强大。3. 使用unique_lock需要付出更多的时间、性能成本。参考链接0voice · GitHub