【C++航海王：追寻罗杰的编程之路】C++11(四)

目录

1 -> 相关文章

【C++航海王：追寻罗杰的编程之路】C++11(一)

【C++航海王：追寻罗杰的编程之路】C++11(二)

【C++航海王：追寻罗杰的编程之路】C++11(三)

2 -> lambda表达式

2.1 -> C++98中的一个例子

2.2 -> lambda表达式

2.3 -> lambda表达式语法

2.4 -> 函数对象与lambda表达式 

3 -> 包装器

 3.1 -> bind 

4 -> 线程库

4.1 -> thread类的简单介绍

C++11中线程类

4.2 -> 线程函数参数

4.3 -> 原子性操作库(atomic) 

4.4 -> lock_guard与unique_lock 

4.4.1 -> mutex的种类 

4.4.2 -> lock_guard

4.4.3 -> unique_lock 

1 -> 相关文章

【C++航海王：追寻罗杰的编程之路】C++11(一)

【C++航海王：追寻罗杰的编程之路】C++11(二)

【C++航海王：追寻罗杰的编程之路】C++11(三)

2 -> lambda表达式

2.1 -> C++98中的一个例子

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <functional>
#include <algorithm>int main()
{int array[] = { 4,1,8,5,3,7,0,9,2,6 };// 默认按照小于比较，排出来结果是升序std::sort(array, array + sizeof(array) / sizeof(array[0]));// 如果需要降序，需要改变元素的比较规则std::sort(array, array + sizeof(array) / sizeof(array[0]), std::greater<int>());return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则： 

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;struct Goods
{string _name;  // 名字double _price; // 价格int _evaluate; // 评价Goods(const char* str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){}
};struct ComparePriceLess
{bool operator()(const Goods& gl, const Goods& gr){return gl._price < gr._price;}
};struct ComparePriceGreater
{bool operator()(const Goods& gl, const Goods& gr){return gl._price > gr._price;}
};int main()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };sort(v.begin(), v.end(), ComparePriceLess());sort(v.begin(), v.end(), ComparePriceGreater());return 0;
}

 随着C++语法的发展，人们开始觉得上面写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类 ，特别是相同类的命名，这些都给使用者带来了极大的不便。因此，在C++11语法中出现了lambda表达式。

2.2 -> lambda表达式

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;struct Goods
{string _name;  // 名字double _price; // 价格int _evaluate; // 评价Goods(const char* str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){}
};int main()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate < g2._evaluate; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; });}

上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式是一个匿名函数。 

2.3 -> lambda表达式语法

lambda表达式书写格式：

[capture-list] (parameters) mutable -> return-type {statement};

 1. lambda表达式各部分说明：

  • [capture-list]：捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
  • (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
  • mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
  • -> return-type：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可以省略。返回值类型明确的情况下，也可以省略，由编译器对返回类型进行推导。
  • {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{};该lambda函数不能做任何事情。

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;int main()
{// 最简单的lambda表达式, 该lambda表达式没有任何意义[] {};// 省略参数列表和返回值类型，返回值类型由编译器推导为intint a = 3, b = 4;[=] {return a + 3; };// 省略了返回值类型，无返回值类型auto fun1 = [&](int c) {b = a + c; };fun1(10);cout << a << " " << b << endl;// 各部分都很完善的lambda函数auto fun2 = [=, &b](int c)->int {return b += a + c; };cout << fun2(10) << endl;// 复制捕捉xint x = 10;auto add_x = [x](int a) mutable { x *= 2; return a + x; };cout << add_x(10) << endl;return 0;
}

通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可以借助auto将其赋值给一个变量。

关于auto，可以去之前的文章：【C++航海王：追寻罗杰的编程之路】引用、内联、auto关键字、基于范围的for、指针空值nullptr 

2. 捕捉列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方法是传值还是传引用。

  • [var]：表示值传递方式捕捉变量var。
  • [=]：表示值传递方式捕捉所有父作用域中的变量(包括this)。
  • [&var]：表示引用传递捕捉变量var。
  • [&]：表示引用传递捕捉所有父作用域中的变量(包括this)。
  • [this]：表示值传递方式捕捉当前的this指针。

注意：

  1. 父作用域指包含lambda函数的语句块。
  2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分隔。比如：[=,  &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量。[&,  a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量。
  3. 捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：[=, a]：=已经以值传递方式捕捉了其他所有变量，捕捉a重复。
  4. 在块作用域以外的lambda函数捕捉列表必须为空。
  5. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
  6. lambda表达式之间不能相互赋值，即使看起来类型相同。
#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;void (*PF)();int main()
{auto f1 = [] {cout << "hello world" << endl; };auto f2 = [] {cout << "hello world" << endl; };//f1 = f2;   // 编译失败--->提示找不到operator=()// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();// 可以将lambda表达式赋值给相同类型的函数指针PF = f2;PF();return 0;
}

2.4 -> 函数对象与lambda表达式 

函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象。 

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;class Rate
{
public:Rate(double rate) : _rate(rate){}double operator()(double money, int year){return money * _rate * year;}private:double _rate;
};int main()
{// 函数对象double rate = 0.49;Rate r1(rate);r1(10000, 2);// lamberauto r2 = [=](double monty, int year)->double {return monty * rate * year;};r2(10000, 2);return 0;
}

从使用方式上来看，函数对象与lambda表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕捉列表可以直接将该变量捕捉到。 

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载operator()。 

3 -> 包装器

function包装器

function包装器，也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;//ret = func(x);
//上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
//是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
template<class F, class T>
T useF(F f, T x)
{static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}double f(double i)
{return i / 2;
}struct Functor
{double operator()(double d){return d / 3;}
};int main()
{// 函数名cout << useF(f, 11.11) << endl;// 函数对象cout << useF(Functor(), 11.11) << endl;// lamber表达式cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;return 0;
}

通过上面的程序验证，我们会发现useF函数模板实例化了三份。

包装器可以很好的解决上面的问题。 

std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;// 使用方法如下：
int f(int a, int b)
{return a + b;
}struct Functor
{
public:int operator() (int a, int b){return a + b;}
};class Plus
{
public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;}
};int main()
{// 函数名(函数指针)std::function<int(int, int)> func1 = f;cout << func1(1, 2) << endl;// 函数对象std::function<int(int, int)> func2 = Functor();cout << func2(1, 2) << endl;// lamber表达式std::function<int(int, int)> func3 = [](const int a, const int b){return a + b; };cout << func3(1, 2) << endl;// 类的成员函数std::function<int(int, int)> func4 = &Plus::plusi;cout << func4(1, 2) << endl;std::function<double(Plus, double, double)> func5 = &Plus::plusd;cout << func5(Plus(), 1.1, 2.2) << endl;return 0;
}

 有了包装器，如何解决模板的效率低下，实例化多份的问题呢？

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;template<class F, class T>
T useF(F f, T x)
{static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}double f(double i)
{return i / 2;
}struct Functor
{double operator()(double d){return d / 3;}
};int main()
{// 函数名std::function<double(double)> func1 = f;cout << useF(func1, 11.11) << endl;// 函数对象std::function<double(double)> func2 = Functor();cout << useF(func2, 11.11) << endl;// lamber表达式std::function<double(double)> func3 = [](double d)->double { return d /4; };cout << useF(func3, 11.11) << endl;return 0;
}

 3.1 -> bind 

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象(callable object)，生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们可以用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个(M可以大于N，但并没有什么意义)参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

//原型如下：
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

调用bind的一般形式：

auto newCallable = bind(callable， arg_list);

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。 

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1作为newCallable的第一个参数，_2为第二个参数，以此类推。

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;// 使用举例
int Plus(int a, int b)
{return a + b;
}class Sub
{
public:int sub(int a, int b){return a - b;}
};int main()
{//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,placeholders::_2);//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);//func2的类型为 function<void(int, int, int)> 与func1类型一样//表示绑定函数 plus 的第一，二为： 1， 2auto  func2 = std::bind(Plus, 1, 2);cout << func1(1, 2) << endl;cout << func2() << endl;Sub s;// 绑定成员函数std::function<int(int, int)> func3 = std::bind(&Sub::sub, s,placeholders::_1, placeholders::_2);// 参数调换顺序std::function<int(int, int)> func4 = std::bind(&Sub::sub, s,placeholders::_2, placeholders::_1);cout << func3(1, 2) << endl;cout << func4(1, 2) << endl;return 0;
}

4 -> 线程库

4.1 -> thread类的简单介绍

在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库中的线程，必须包含<thread>头文件。

C++11中线程类

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

 注意：

1. 线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态。

2.  当创建一个线程对象后，没有提供线程函数，该对象实际没有任何对应线程。

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;int main()
{std::thread t1;cout << t1.get_id() << endl;return 0;
}

get_id()的返回值类型为id类型，id类型实际为std::thread命名空间下封装的一个类，该类中包含了一个结构体。 

// vs下查看
typedef struct
{ /* thread identifier for Win32 */void* _Hnd; /* Win32 HANDLE */unsigned int _Id;
} _Thrd_imp_t;

 3. 当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。线程函数一般情况下可按照以下三种方式提供：

  • 函数指针
  • lambda表达式
  • 函数对象
#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <algorithm>
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;
}

4. thread类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即，将一个线程对象关联线程的状态转移给其他线程对象。

5. 可以通过joinable()函数判断线程是否有效的，如果是以下任意情况，则线程无效。

  • 采用无参构造函数构造的线程对象
  • 线程对象的状态已经转移给其他线程对象
  • 线程已经调用join或者detach结束 

4.2 -> 线程函数参数

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

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <algorithm>
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;
}

注意：

如果是类成员函数作为线程参数时，必须将this作为线程函数参数。 

4.3 -> 原子性操作库(atomic) 

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

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <functional>
#include <algorithm>
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中传统的解决方法：可以对共享修改的数据加锁保护。  

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <functional>
#include <algorithm>
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引入的原子操作类型，使得线程间数据的同步变得非常高效。 

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <vector>
#include <functional>
#include <algorithm>
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类模板，定义出需要的任意原子类型。 

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

注意：

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

4.4 -> lock_guard与unique_lock 

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

比如：一个线程对变量number进行加一100次，另外一个减一100次，每次操作加一或者减一之
后，输出number的结果，要求：number最后的值为1。

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <vector>
#include <functional>
#include <algorithm>
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。

4.4.1 -> mutex的种类 

在C++11中，mutex总共包括四个互斥量的种类：

1. std::mutex

C++11提供的最基本的互斥量，该类的对象之间不能拷贝，也不能进行移动，mutex最常用的三个函数：

函数名函数功能
lock()上锁：锁住互斥量
unlock()解锁：释放对互斥量的所有权
try_lock()尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞

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

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

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

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

2. std::recursive_mutex

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

3. 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。


4. std::recursive_timed_mutex

4.4.2 -> lock_guard

std::lock_guard是C++11中定义的模板类。定义如下：

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;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对象要被销毁，调用析构函数自动解锁，可以有效避免死锁
问题。

lock_guard的缺陷：太单一，用户没有办法对该锁进行控制，因此C++11又提供了unique_lock。 

4.4.3 -> 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所管理的互斥量的指针)。

感谢大佬们的支持！！！

互三啦！！！

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Python 与 TensorFlow2 生成式 AI（三）

Python 与 TensorFlow2 生成式 AI（三）

原文&#xff1a;zh.annas-archive.org/md5/d06d282ea0d9c23c57f0ce31225acf76 译者&#xff1a;飞龙 协议&#xff1a;CC BY-NC-SA 4.0 第七章&#xff1a;使用 GAN 进行风格转移 神经网络在涉及分析和语言技能的各种任务中正在取得进步。创造力是人类一直占有优势的领域&…
阅读更多...
MetaGPT初体验之HelloWorld-Git教程编写

MetaGPT初体验之HelloWorld-Git教程编写

[目录] 1.环境准备 2.效果预览 3.总结 4.智能体完整输出 5.源码及教程点我去AIGIS公众号查看本文 前言 5.1假期坚持研究智能体的玩法可以说非常敬业了。今天我们来小试一把目前GitHub最火爆智能体框架MetaGPT,让它给我们写一篇Git教程&#xff0c;看看是不是像传说中的那么神奇…
阅读更多...
判断循环链表以及其环入口

判断循环链表以及其环入口

文章目录 题目题目链接题目要求 解题思路方法一&#xff1a;哈希表方法二&#xff1a;双指针 进阶思考快指针一次走三步 进阶问题&#xff08;入口点&#xff09;题目链接题目要求问题思路 总结 题目 题目链接 环形链表 题目要求 解题思路 显而易见的是&#xff0c;单纯的遍…
阅读更多...
day7 c++

day7 c++

整理代码 1、unique_ptr 指针 #include <iostream> #include <memory> using namespace std; class Demo {public:Demo(){cout<<"无参构造"<<endl;}~Demo(){cout<<"Demo的析构函数"<<endl;} };int main() {//unique…
阅读更多...
【IDEA】IDEA自带Maven/JDK，不需要下载

【IDEA】IDEA自带Maven/JDK，不需要下载

IDEA是由Java编写的&#xff0c;为了保证其运行&#xff0c;内部是自带JDK的。IDEA 2021 及 之后的版本是自带Maven的&#xff1a; 视频连接&#xff1a; https://www.bilibili.com/video/BV1Cs4y1b7JC?p4&spm_id_frompageDriver&vd_source5534adbd427e3b01c725714cd…
阅读更多...
理解Linux文件系统

理解Linux文件系统

文章目录 一、引言二、Linux文件系统概述1、文件系统的结构2、文件系统目录树的逻辑结构 二、文件系统的特性1、super block&#xff1a;文件系统的超级块2、inode&#xff1a;文件系统的索引节点3、inode table4、block&#xff1a;文件系统的数据块5、块组描述符表&#xff0…
阅读更多...
链表例题（分割链表）

链表例题（分割链表）

链接&#xff1a; . - 力扣&#xff08;LeetCode&#xff09; 题目描述&#xff1a; 即将小于特定值的节点放在前面&#xff0c;大于特定值的节点接在后面 思路&#xff1a; 我们可以创建两个链表分别存放大于的值和小于的值。5个变量&#xff08;记录链表当前位置的指针st…
阅读更多...
Spring Kafka——基于 Spring Kafka 实现动态管理 Kafka 连接和 topic 的监听

Spring Kafka——基于 Spring Kafka 实现动态管理 Kafka 连接和 topic 的监听

文章目录 使用 Spring Kafka 动态管理 Kafka 连接和主题监听1. 前言2. 简单的消费程序配置3. Spring Kafka 主要的相关类的说明4. KafkaListener 注解的加载执行流程解析5. 动态监听消费订阅的设计与实现 使用 Spring Kafka 动态管理 Kafka 连接和主题监听 文章内容较长&#x…
阅读更多...
css div块标签内的多个英语单词怎样设置换行

css div块标签内的多个英语单词怎样设置换行

背景&#xff1a; 在<div>标签内&#xff0c;当接口返回的字符串全是英文字母&#xff0c;不会自动换行。 原因&#xff1a;查过相关资料后才知道&#xff0c;只有英文文本才会出现不能自动换行的情况&#xff0c;&#xff08;中文不存在&#xff09;而原因是因为英文文本…
阅读更多...
【antd + vue】InputNumber 数字输入框 输入限制

【antd + vue】InputNumber 数字输入框 输入限制

一、需求说明 只能输入数字和小数点&#xff0c;保留小数点后两位&#xff1b;最多输入6位&#xff1b;删除所有内容时&#xff0c;默认为0&#xff1b; 二、问题说明 问题1&#xff1a;使用 precision 数值精度 时&#xff0c;超出规定小数位数时会自动四舍五入&#xff1b;…
阅读更多...
水库大坝安全白蚁监测系统解决方案

水库大坝安全白蚁监测系统解决方案

一、系统背景 白蚁作为河岸生态系统中的重要病害&#xff0c;不仅会导致水库大坝外部环境发生改变&#xff0c;甚至会引发水库大坝破坏&#xff0c;进而导致自身结构失去稳定性&#xff0c;严重影响水库大坝的正常运行。因此&#xff0c;治理水库大坝白蚁是确保水库大坝工程顺利…
阅读更多...
翻译: 什么是ChatGPT 通过图形化的方式来理解 Transformer 架构 深度学习二

翻译: 什么是ChatGPT 通过图形化的方式来理解 Transformer 架构 深度学习二

合集 ChatGPT 通过图形化的方式来理解 Transformer 架构 翻译: 什么是ChatGPT 通过图形化的方式来理解 Transformer 架构 深度学习一翻译: 什么是ChatGPT 通过图形化的方式来理解 Transformer 架构 深度学习二翻译: 什么是ChatGPT 通过图形化的方式来理解 Transformer 架构 深…
阅读更多...
STM32中断之TIM定时器详解

STM32中断之TIM定时器详解

系列文章目录 STM32单片机系列专栏 C语言术语和结构总结专栏 文章目录 1. TIM简述 2. 定时器类型 2.1 基本定时器 2.2 通用定时器 2.3 高级定时器 3. 定时中断 4. 代码示例1 5. 代码示例2 1. TIM简述 定时器的基本功能&#xff1a;定时器可以在预定的时间间隔内产生周…
阅读更多...
谷歌研发“SEEDS”新型天气预报模型：更准确地报道极端事件

谷歌研发“SEEDS”新型天气预报模型：更准确地报道极端事件

谷歌科技近日公布了一项震撼业界的天气预报研究成果&#xff0c;这一成果不仅标志着天气预测技术的重大突破&#xff0c;更是人工智能技术在传统领域应用的又一里程碑。他们成功研发了名为SEEDS&#xff08;Scalable Ensemble Envelope Diffusion Sampler&#xff09;的新型预报…
阅读更多...
【AIGC】深入探索AIGC技术在文本生成与音频生成领域的应用

【AIGC】深入探索AIGC技术在文本生成与音频生成领域的应用

&#x1f680;文章标题 &#x1f680;AIGC之文本生成&#x1f680;应用型文本生成&#x1f680;创作型文本生成&#x1f680;文本辅助生成&#x1f680;重点关注场景 &#x1f680;音频及文字—音频生成&#x1f680;TTS(Text-to-speech)场景&#x1f680;乐曲/歌曲生成&#x…
阅读更多...
访问jwt生成token404解决方法

访问jwt生成token404解决方法

背景&#xff1a; 1.在部署新的阿里云环境后发现调用jwt生成token的方法404&#xff0c;前端除了404&#xff0c;台不报任何错误 在本地好用&#xff0c;在老的阿里云环境好用&#xff0c; 2.缩短生成私钥的参数报错&#xff0c;以为私钥太长改了tomcat参数也无效&#xff0…
阅读更多...
手撕C语言题典——合并两个有序数组（顺序表）

手撕C语言题典——合并两个有序数组（顺序表）

搭配食用更佳哦~~ 数据结构之顺顺顺——顺序表-CSDN博客 数据结构之顺序表的基本操作-CSDN博客 继续来做一下关于顺序表的经典算法题叭~ 前言 88. 合并两个有序数组 - 力扣&#xff08;LeetCode&#xff09; 合并数组也是力扣上关于顺序表的一道简单题&#xff0c;继续来加深…
阅读更多...
YARN详解

YARN详解

YARN 简介 YARN 是Yet Another Resource Negotiator的缩写。 YARN是第二代MapReduce,即MRv2,是在第一代MapReduce基础上演变而来的,主要是为了解决原始Hadoop扩展性较差,不支持多计算框架而提出的;通俗讲就是资源管理器. YARN核心思想: 将 MR1 中资源管理和作业调度两个功能分…
阅读更多...
数据结构：实验六：图的操作

数据结构：实验六：图的操作

一、 实验目的 &#xff08;1&#xff09;掌握图的邻接矩阵和邻接表存储结构。 &#xff08;2&#xff09;熟练图的邻接表的基本运算。 &#xff08;3&#xff09;加深图的深度优先遍历算法和广度优先遍历算法的理解 二、 实验要求 有下图所示的带权有向图及其对应的邻…
阅读更多...
【工程记录】Python爬虫入门记录（Requests BeautifulSoup）

【工程记录】Python爬虫入门记录（Requests BeautifulSoup）

目录 写在前面1. 环境配置2. 获取网页数据3. 解析网页数据4. 提取所需数据4.1 简单提取4.2 多级索引提取 5. 常见问题 写在前面 仅作个人学习与记录用。主要整理使用Requests和BeautifulSoup库的简单爬虫方法。在进行数据爬取时&#xff0c;请确保遵守相关法律法规和网站的服务…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023