1、类型与变量相关

1.1、nullptr:

取代了NULL,专用于空指针

1.2、constexpr:

近似const, 可以修饰变量,也可以修饰函数,

修饰变量如:

const int global = 100;

int main () {

int temp = 100;

constexpr int a = 1; //right

constexpr int b = global; //right

constexpr int c = temp; //wrong

}

既可以赋值字面常量也可以赋值以const变量

重点:constexpr修饰的函数,生效于编译时而不是运行时, 重点应用于修饰函数使其在编译期大幅度被解释

被constexpr修饰的函数,无论是普通函数,还是类成员函数,必须是编译器可计算得到结果,即字面常量,不可是运行时才能获取的内容

例1:

constexpr int calc_in_compile_0 () {
    return 100;
}
constexpr int calc_in_compile_1 (int a) {
    return a * 100;
}
constexpr int calc_in_compile_2 (int b, int c) {
return c * calc_in_compile_1(b);
}

EXPECT_EQ(100, calc_in_compile_0());

constexpr int a = 1;

EXPECT_EQ(100, calc_in_compile_1(a));

EXPECT_EQ(10000, calc_in_compile_2(a, calc_in_compile_1(a)));

例2:

代替了"const _max = INT_MAX"

static constexpr int max () {
     return INT_MAX;
}
static constexpr int min () {

return INT_MIN;
}

constexpr int _max = max(), _min = min();

例3:

class Calc {
    double a_;
public:
    /*构造函数在这里,必须用constexpr修饰,因为类成员函数是用constexpr修饰的*/
    constexpr Calc(double a):a_(a) {}

constexpr double GetFabs() const {
return std::fabs(a_);
}
    constexpr double GetAbs() const {
        return std::abs(a_);
    }
    constexpr double GetSquare() const {
        return a_ * a_;
    }
};

constexpr Calc calc(5.1);
    constexpr double _fabs = calc.GetFabs();
    ///_fabs = 10.0;
    LOG(INFO) << "fabs: " << _fabs;
    double _abs = calc.GetAbs();
    LOG(INFO) << "abs: " << _abs;
    _abs = 10.0;
    LOG(INFO) << "abs: " << _abs;
    double _square = calc.GetSquare();
    LOG(INFO) << "square: " << _square;
    _square = 10.0;
    LOG(INFO) << "square: " << _square;

1.3、using取代typedef:

typedef double db;
//c99

using db = double;
//c++11

typedef void(*function)(int, int);//c99,函数指针类型定义

using function = void(*)(int, int);//c++11,函数指针类型定义

using kvpairs = std::map<std::string, std::string>;
//c++11

using CompareOperator = std::function<int (kvpairs &, kvpairs &)>;
//c++11

using query_record = std::tuple<time_t, std::string>;
//c++11

template<class T> using twins = std::pair<T, T>;
//更广泛的还可以用于模板

1.4、auto & decltype:

auto让编译器通过初始值来推算变量的类型。当然,其定义的变量必须要有初始值

auto a = 1;

auto task = std::function<void ()>([this, a] {

................

});

decltype(变量)可以获取变量的类型

auto a = 1;

decltype(a) b = 2;

decltype(b) c = add(a, b);

注意下,decltype((a) )的结果是引用,此时创建新的变量就将会报错,或者说:

int &b = a;

decltype(b) c;//也报错,因为b是a的引用,decltype(b)就会报错,效果同decltype((a))

此外,auto在容器的迭代器的使用,大大降低了代码开发量

对于vector、map、set等容器

for (auto i: V) {

......

}

1.5、字符串和数值类型的转换

以前的atoi、itoa等等成为历史

to_string:itoa成为历史

stoi、stol、stoul、stoll、stoull、stof、stod、stold:atoX成为历史

1.5、random_device

生成随机数,免去了以前需要自行调用srand初始化种子的步骤,因为有时忘了初始化结果导致错误。用法:

std::random_device
rd;

int randint =
rd();

1.6、std::ref和std::cref

分别对应变量的引用和const引用,主要用于作为c++11函数式编程时传递的参数

1.7、std::chrono时间相关

比以前的时间方便了许多:

std::chrono::duration<double> duration
//时间间隔

std::this_thread::sleep_for(duration);
//sleep

LOG(INFO) << "duration is " << duration.count() << std::endl;

std::chrono::microseconds 
//微秒

std::chrono::seconds //秒

end = std::chrono::system_clock::now();
//获取当前时间

1.8、原子变量

std::atomic<XXX>

用于多线程资源互斥操作,属c++11重大提升,多线程原子操作简单了许多

事实上基于c++11实现的无锁队列,让boost::lockfree无锁队列也将成为历史

1.9、正则表达式std::regex

恶心的C正则(regex.h)和boost正则成为历史

1.10、编译期断言static_assert

static_assert是用于涉及模板的assert,编译期就能发现不满足的情况,无需等到运行时出现core

如下最后一个被注掉的static_assert如果放开,则无法通过编译。

  1. template<class T> class C {
  2. T data1_;
  3. int data2_;
  4. public:
  5. C(T data1, int data2):data1_(data1), data2_(data2) {
  6. /*if the condition is not satisfiedm, would be errored by compiler in compling*/
  7. //static_assert(sizeof(T) > 4, "sizeof(T) is not larger than 4");
  8. static_assert(sizeof(T) >= 4, "sizeof(T) is not larger than 4");
  9. //static_assert(data2_ >= 10, "could not use static_assert here! condition must could be calced in compling!");
  10. }
  11. };
  12. TEST(test_static_assert, test) {
  13. C<double> c(1.1, 1);
  14. }

2、容器

2.1、tuple & 花括号初始化

元组的出现,和python拉齐了,c++也实现了函数可以多个返回值

using  result = std::tuple<int, char, double>;

result res = {1,'a',1.0};

return res;

return {2, 'b',100.0};

std::vector<int> v{1, 2, 3, 4, 5};

using res_tp = std::tuple<bool, char, int, float, double>;

res_tp res(true, 'b', 11, 1.1, 100.1);

LOG(INFO) << "res.bool: " << std::get<0>(res);
    LOG(INFO) << "res.char: " << std::get<1>(res);
    LOG(INFO) << "res.int: " << std::get<2>(res);
    LOG(INFO) << "res.float: " << std::get<3>(res);
    LOG(INFO) << "res.double: " << std::get<4>(res);

以上都是合法的,尤其对vector,简单的测试程序再不需要一行行的push_back了!

2.2、hash正式进入stl

unordered_map、unordered_set、unordered_multimap、unordered_multiset。extstl扩展方式的使用hash成为历史。

2.3、emplace:

作用于容器,区别于push、insert等,如push_back是在容器尾部追加一个容器类型对象,emplace_back是构造1个新对象并追加在容器尾部

对于标准类型没有变化,如std:;vector<int>,push_back和emplace_back效果一样

如自定义类型class A,A的构造函数接收一个int型参数,

那么对于push_back需要是:

std::vector<A> vec;

A a(10);

vec.push_back(a);

对于emplace_back则是:

std::vector<A> vec;

vec.emplace_back(10);

改进点是什么?改进点:避免无用临时变量。比如上面例子中的那个a变量

2.4、int> v{1, 2, 3, 4, 5};

  • v.push_back(1);
  • std::cout << "before shrink_to_fit: " << v.capacity() << std::endl;
  • v.shrink_to_fit();
  • std::cout << "after shrink_to_fit: " << v.capacity() << std::endl;

可以试一试,减少了很多,有一定价值

3、对于类

3.1、构造函数

3.1.1、控制构造函数

1、default关键字生成默认构造函数和析构函数

default的默认构造方式可生成:默认无参数的构造函数、拷贝构造函数、赋值构造函数

析构函数同样可以由default默认构造

  1. class A11 {
  2. int data;
  3. public:
  4. A11() = default;
  1. ~A11() = default;
  2. A11 (int _data):data(_data) {}
  3. };
  4. void c11_construct () {
  5. A11 a;
  6. A11 b(a);
  7. A11 c;
  8. c = b;
  9. A11 d(1);
  10. }

2、delete关键字禁止拷贝构造、禁止赋值构造、禁止自定义参数的构造函数

注意析构函数不可由delete修饰

c++11以前的方式,是把需要禁止的构造函数,放在private里使外部无法调用;

c++11风格的禁止构造的noncopyable基类实现如下,禁止了拷贝构造和赋值构造:

  1. class noncopyable {
  2. protected:
  3. constexpr noncopyable() = default;
  4. ~noncopyable() = default;
  5. noncopyable(const noncopyable &) = delete;
  6. noncopyable &operator= (const noncopyable &) = delete;
  7. };

3、委托构造函数

一个构造函数,使用自己的参数,传递给其他构造函数去构造,作为自己的构造函数实现,

如下例,后面两个构造函数,均传递参数,委托给第一个构造函数去实现

  1. <span style="font-size:10px;">struct A {
  2. bool a_;
  3. char b_;
  4. int c_;
  5. float d_;
  6. double e_;
  7. A(bool a, char b, int c, float d, double e): a_(a), b_(b), c_(c), d_(d), e_(e) {}
  8. //construct reuse
  9. A (int c): A(true, 'b', c, 1.1, 1000.1) {}
  10. A (double e): A (false, 'a', 0, 0.1, e) {}
  11. };
  12. A o1(10);
  13. LOG(INFO) << "a: " << o1.a_ << ", b: " << o1.b_ << ", c: " << o1.c_ << ", d: " << o1.d_ << ", e: " << o1.e_;
  14. A o2(5.5);
  15. LOG(INFO) << "a: " << o2.a_ << ", b: " << o2.b_ << ", c: " << o2.c_ << ", d: " << o2.d_ << ", e: " << o2.e_;</span>

4、移动构造函数:

属于c++11的右值引用的衍生效果之一,首先描述右值引用std::move

std::move主要能解决的拷贝性能问题

类似于python的深拷贝和浅拷贝, python中的对象赋值和copy.copy都是浅拷贝, 赋值的都是对象的引用, copy.deepcopy则是深拷贝

首先插一段python代码帮助理解深浅拷贝,建议用pdb跟一下代码感受更加深刻:

  1. <span style="font-size:10px;">import copy
  2. import json
  3. a = [1, 2, 3, 4, 5, [99, 98]]
  4. #b全都是a的引用
  5. b = a
  6. #c的非子对象都是a的复制构造, 但子对象还是引用
  7. c = copy.copy(a)
  8. #d全都是a的复制构造                                                                        </span>
  1. <span style="font-size:10px;">d = copy.deepcopy(a)
  2. print "a append a new element 100"
  3. a.append(100)
  4. print "a: %s" % json.dumps(a)
  5. print "b = a, b will change: %s" % json.dumps(b)
  6. print "c = copy.copy(a): %s" % json.dumps(c)
  7. print "d = copy.deepcopy(a): %s" % json.dumps(d)
  8. print "a's subobject append a new element 100"
  9. a[5].append(100)
  10. print "a: %s" % json.dumps(a)
  11. print "b = a, b will change: %s" % json.dumps(b)
  12. print "c = copy.copy(a), will change: %s" % json.dumps(c)
  13. print "d = copy.deepcopy(a): %s" % json.dumps(d) </span>

直接定位到实际应用上(程序中尽量不要出现"int &&a = 1"这样的东西,炫技容易搞出错误)
c++11的std::move, 解决的问题是一个复制效率的问题:

对临时变量(如函数中的参数)的复制,通过更改对象的所有者(move),实现免内存搬迁或拷贝(去除深拷贝),

提高"复制"效率(其实不是复制,仅是更改了对象的所有者

例一:改变引用持有者(减少复制成本,移交引用权力给有用的变量,同时免除不再有用变量对引用的持有权)

  1. <span style="font-size:10px;">    std::string a = "123";    //或std::string &&a = "123";显示的标识a是全局字符串"123"的右值引用
  2. LOG(INFO) << "at first, std::string a is: " << a;   //打印123
  3. /*右值"123", 它的所有者将从原先的左值(变量std::string a), 转移到新的左值(std::vector v)
  4. *所以, 使用std::move时一定保证, 以前的左值不再真需要了. 典型使用场合就是: (构造)函数的参数, 避免了再复制*/
  5. v.push_back(std::move(a));
  6. LOG(INFO) << "after std::move(a), now std::string a is: " << a; //打印空</span>

最后的glog将无法打印出a最开始的拷贝构造获取的值"123",因为全局字符串"123"的所有者,已经从最开始的变量a,转移到了v

这在日常场合也是需要的,用途为:

1、减少内存复制成本

2、将不再需要的变量,取消它对原先持有变量(内存)的持有(修改)权限

例二:移动构造函数

  1. <span style="font-size:10px;">    class test {
  2. public:
  3. std::vector<std::string> t_;
  4. test(std::vector<std::string> &tmp) {
  5. for (auto& i: tmp) {
  6. //not copy rvalue to t_, only add rvalue reference to t_ and update rvalue's lifecycle
  7. t_.push_back(std::move(i));
  8. }
  9. }
  10. };
  11. /*起初, 右值("123", "456", "789", "012", "345")都归属于左值temp*/
  12. std::vector<std::string> temp = {"123", "456", "789", "012", "345"};
  13. LOG(INFO) << "before move to object ot, t's size is: " << temp.size();
  14. for (auto& i: temp) {
  15. LOG(INFO) << " OLD LVALUE(object temp) element: " << i;
  16. }
  17. /*由类test的构造函数, 更改右值的所有者为类test的对象ot*/
  18. test ot(temp);
  19. LOG(INFO) << "after move elements of temp to object ot, now ot's size is: " << ot.t_.size();
  20. for (auto& i: temp) {
  21. LOG(INFO) << " OLD LVALUE(object temp) element: " << i;
  22. }
  23. for (auto& i: ot.t_) {
  24. LOG(INFO) << " NEW LVALUE(object ot) element: " << i;
  25. }</span>

第一轮glog, vector容器temp可以打印出其持有的全局字符串列表

第二轮glog:
因为全局字符串列表的每一个字符串的引用,均被move到test类对象ot的成员变量t_中,vector容器temp不再持有全局字符串列表中每一个字符串的引用权限
故无法打印
第三轮glog:
对象ot的成员t_持有全局字符串列表每一个字符串的引用,所以可以打印
移动构造函数,最大的用途避免同一份内存数据的不必要的变成两份甚至多份、过程中的变量传递导致的内存复制,另外解除了栈变量对内存的引用
实际应用时往往如下这样:
int main () {
var a = XXX;
var b = YYY;
.....
object obj(a,b,.....);//使用移动构造函数,免去a的复制构造成本(避免深拷贝造成XXX、YYY在main里有一份,obj里还有一份,而且obj构造时可能还得内存复制),另外以后临时变量a再无权修改对应内存,完全消除全部隐患
}

例三:c++11风格的新老容器的数据移交:

如果一个老容器如vector容器oldv,需要将其内部数据复制给新容器如vector容器newv,且老容器后面无用,数据量很大;

那么c++11的std::"font-size:10px;"><span style="font-family:Courier New, sans-serif;">std::vector<std::string> oldv = {"123", "456", "789"};

  • std::vector<std::string> newv(oldv.size());
  • for (auto &i: oldv) {
  • std::cout << i << "\t";
  • }
  • std::cout << std::endl;
  • <strong><span style="color:#ff0000;">std::copy(std::make_move_iterator(oldv.begin()), std::make_move_iterator(oldv.end()), newv.begin());   //c++11做法,move引用</span></strong></span></span>
  1. <span style="font-size:10px;"><span style="font-family:Courier New, sans-serif;"><strong><span style="color:#ff0000;">    //std::copy(oldv.begin(), oldv.end(), newv.begin());  //传统做法,复制</span></strong>
  2. for (auto &i: oldv) {
  3. std::cout << i << "\t";
  4. }
  5. std::cout << std::endl;
  6. for (auto &i: newv) {
  7. std::cout << i << "\t";
  8. }
  9. std::cout << std::endl;</span></span>

第一次打印:老容器正常打印

第二次打印:老容器无法打印了,因为每个
第三次打印:新容器正常打印

关于右值引用是c++11的一大重点,还有很多其他相关内容,个人认为理解和运用到这里基本可满足了。

5、继承构造函数

回到c++11的关于类的构造问题,近似于委托构造函数原理,如下:

  1. struct A {
  2. int a;
  3. A(int _a):a(_a + 100){}
  4. };
  5. struct B : public A {
  6. int b;
  7. B(int _b):A(_b), b(_b + 10000){}
  8. };
  9. B obj(1);
  10. std::cout << obj.a << ", " << obj.b << std::endl;

3.2、override和final

作用于虚函数,更多的作用是:显式的标识是否应该多态继承或不应该

1、override:子类用override修饰其虚函数,表示要多态继承基类的虚函数。不可以修饰非虚函数

举一个rocksdb的merge运算符重载的例子:

  1. class ProcessMerge : public rocksdb::MergeOperator {
  2. public:
  3. virtual bool FullMergeV2 (const MergeOperationInput &merge_in,
  4. MergeOperationOutput *merge_out) const override {
  5. merge_out->new_value.clear();
  6. if (merge_in.existing_value != nullptr) {
  7. merge_out->new_value.assign(merge_in.existing_value->data(), merge_in.existing_value->size());
  8. }
  9. for (const rocksdb::Slice& m : merge_in.operand_list) {
  10. merge_out->new_value.append("|");
  11. merge_out->new_value.append(m.data(), m.size());
  12. }
  13. return true;
  14. }
  15. const char* Name() const override { return "ProcessMerge"; }
  16. };

2、final:基类用final修饰其虚函数,意外其子类不可以多态继承该虚函数

  1. class father {
  2. public:
  3. int a_;
  4. int GetA() {return a_;}
  5. virtual void SetA(int a) {
  6. a_ = a;
  7. LOG(INFO) << "father modify a to " << a_;
  8. }
  9. //add keyword final to avoid non-anticipated inherit in compling but not errored in running
  10. //virtual void SetA(int a) final {a_ = a;}
  11. public:
  12. father(int a):a_(a) {}
  13. };
  14. class Son: public father {
  15. int b_;
  16. public:
  17. Son(int a, int b):father(a), b_(b) {}
  18. //add keyword override to avoid the error in compling but not errored in running.(eg. 'int SetA(double a){...} override' woule be errored by compiler)
  19. virtual void SetA(int a) override {
  20. a_ = a;
  21. LOG(INFO) << "son modify a to " << a_;
  22. }
  23. //virtual void SetA(double a) override {a_ = a;}
  24. };

如father基类的SetA实现为"virtual void SetA(int a) final {a_ = a;}",则子类Son再多态继承实现SetA方法就会报错了。

3.3、建议:

构造与析构:全部的复制构造、赋值构造、所有权移动构造、自定义构造函数,以及全部的复制运算符、赋值运算符、所有权移动运算符,尽可能自行全部都实现

继承:子类的虚函数多态实现要加override显式的表明,不让子类多态实现的虚函数也要记得加入final;

宗旨:让c++11的编译器更多的帮助发现问题

4、lambda、bind、function:

函数式编程是c++11重要亮点之一

4.1、直接lambda表达式

完全如同python

  1. int a = 1, b = 2;
  2. auto multi = [](int a, int b){
  3. b = a + a + a;
  4. return a + b;
  5. };
  6. LOG(INFO) << "by lambda: " << multi(a, b);

函数multi

4.2、c++11风格的函数指针std::function
& std::bind

  1. int func1 (int a, int b) {
  2. b = a + a + a;
  3. return a + b;
  4. }
  5. auto a = 1, b = 2;
  6. std::function<int (int, int)> modify_add0(func1);
  7. LOG(INFO) << "directly assign function: " << modify_add0(a, b);

通过指定返回值、参数列表、绑定的函数和函数名,定义一个函数(指针)modify_add0

绑定的函数,可以是普通函数,也可以是类成员函数,同时指定:

  1. class ca {
  2. public:
  3. bool func(int a) {
  4. LOG(INFO) << "aaa: " << a;
  5. }
  6. };
  7. ca o;
  8. std::function<bool (int)> f = std::bind(&ca::func, o, std::placeholders::_1);
  9. f(1);

原先只有在boost出现且极为受限的函数占位符,也加入到了标准库,即std::placeholders,传递自定义参数

绑定类成员函数时,需要配合使用std:bind。

bind和placeholders,同样可以用于普通函数:

  1. int func1 (int a, int b) {
  2. b = a + a + a;
  3. return a + b;
  4. }
  5. auto a = 1, b = 2;
  6. auto auto1 = std::bind(func1, std::placeholders::_1, std::placeholders::_2);
  7. LOG(INFO) << "directly run auto: " << auto1(a, b);

auto可以自动识别标准类型的变量的类型,同样可以用于std:;function:

  1. int func1 (int a, int b) {
  2. b = a + a + a;
  3. return a + b;
  4. }
  5. auto a = 1, b = 2;
  6. auto auto1 = std::bind(func1, std::placeholders::_1, std::placeholders::_2);
  7. LOG(INFO) << "directly run auto: " << auto1(a, b);

std:;function作为函数指针,同样可以作为参数传递并执行:

  1. int func1 (int a, int b) {
  2. b = a + a + a;
  3. return a + b;
  4. }
  5. int func3 (auto f) {
  6. return f(1, 2);
  7. }
  8. auto a = 1, b = 2;
  9. auto auto1 = std::bind(func1, std::placeholders::_1, std::placeholders::_2);
  10. LOG(INFO) << "run auto in function: " << func3(auto1);

bind内不仅不再有boost占位符实现的1st、2nd的个数限制,还可以传递常量,并可以指定参数的顺序:

  1. int func2 (int a, double b, std::string c) {
  2. b = a + a + a;
  3. return int(a + b);
  4. }
  5. /*std::function内的定义了该function调用时的顺序, 也是_1、_2、..._n的顺序, bind内要整理符合绑定的函数参数顺序*/
  6. std::function<int (std::string, int)> modify_add2 = std::bind(func2, std::placeholders::_2, 2.0, std::placeholders::_1);
  7. LOG(INFO) << "by bind with partly arg: " << modify_add2("aaa", 1);

modify_add2函数执行时,第一个参数"aaa"第二个参数1,貌似和绑定的函数func2的顺序不符,就是因为bind内指定了占位符标识,占位符2作为第一个参数,常量2.0作为第二个参数,占位符1作为第三个参数,即1、2.0、"aaa"

更广泛的用法,直接定义函数体:

  1. std::function<int ()> modify_add3 = std::function<int ()>([=, &b]{
  2. b = a + a + a;
  3. return a + b;
  4. });
  5. LOG(INFO) << "directly in-function: " << modify_add3();

这个做法是后面描述的std::thread的典型适配方法,让static void thread_func(void *arg) {......}作为线程执行函数体的作法成为历史

对于函数参数为引用、常引用、指针的方法:

  1. int func4 (const int &a, int &b) {
  2. b = 3;
  3. return a + b;
  4. }
  5. int func5 (int *a) {
  6. return *a;
  7. }
  8. std::function<int (const int&, int&)> modify_add4 = std::bind(func4, std::placeholders::_1, std::placeholders::_2);
  9. LOG(INFO) << "args is const reference and reference: " << modify_add4(std::cref(a), std::ref(a));
  10. std::function<int (int *)> modify_add5 = std::bind(func5, std::placeholders::_1);
  11. LOG(INFO) << "args is const reference and reference: " << modify_add5(&a);

在这里,std::ref、std::cref派上了用场

5、动态指针

这也是c++11一个重要亮点

如同函数式编程,动态指针同样大量移植了原先boost里的东西

5.1、unique_ptr

功能基本对应boost的scoped_ptr,或之前stl的auto_ptr,生命周期随构造者,reset自动析构再重新构造,get判断是否有效、支持放在容器内;

真正意义智能指针。

不论是临时变量指针、类成员指针变量.....90%的指针都应该用这个

5.2、shared_ptr

功能对于boost的shared_ptr,可以有多个持有者的共享指针,即所谓引用计数型指针,直到最后一个持有者delete释放时,其指向的资源才会真正被释放

典型应用案例:如对同一个全局无锁队列对象由shared_ptr封装,多线程的多个持有者均持有对其的引用。直到全部线程都释放掉对其的引用时,该无锁队列对象才会被最终销毁。

也就是shared_ptr适合用于管理“全局动态资源”

6、多线程与互斥同步(互斥锁,条件变量)

这也是c++11的一个重要亮点

c++11的多线程管理瞬间变得和boost甚至比boost的还要方便:

  1. static void *ThreadFunc(void *arg) {
  2. reinterpret_cast<ThreadPool *>(arg)->process();
  3. return 0;
  4. }
  5. int a = new int;
  6. std::thread th(&ThreadFunc, (void *)&a);

一个线程池的构造:

  1. ThreadPool::ThreadPool (int thread_num): thread_num_(thread_num),
  2. pending_num_(0),
  3. running_num_(0),
  4. task_count_(0),
  5. stop_(true) {
  6. Start();
  7. }
  8. ThreadPool::~ThreadPool () {
  9. Stop(false);
  10. }
  11. bool ThreadPool::Start () {
  12. std::unique_lock<std::mutex> lock(mtx_);
  13. stop_ = false;
  14. for (auto i: common::Range(0, thread_num_)) {
  15. ths_.push_back(std::thread(&ThreadFunc, this));
  16. }
  17. }

就是这样创建并运行

结合前边的std::function,可以让static void ThreadFunc(void *arg)成为历史:

  1. std::unique_ptr<std::thread> agent_;
  2. agent_.reset(new std::thread([this] () {
  3. while (1) {
  4. std::unique_lock<std::mutex> lock(mtx_);
  5. if (!lockfreequeue_.get() || (lockfreequeue_->empty() && !stop_)) {
  6. std::cv_status cvsts = cond_.wait_for(lock, std::chrono::milliseconds(100));
  7. if (cvsts == std::cv_status::timeout) {
  8. continue;
  9. }
  10. }
  11. if (stop_) {
  12. break;
  13. }
  14. void *msg = nullptr;
  15. lockfreequeue_->pop(msg);
  16. if (msg) {
  17. Task task = std::bind(&DataPreProcess::PreProcess, this, msg);
  18. workers_->AddTask(task);
  19. }
  20. }
  21. LOG(INFO) << "agent thread exit.";
  22. }));

即,直接定义函数体。在c++11直接定义函数体代替静态函数是非常常用的方式。

提到多线程,不能不提到多线程互斥与同步,c++11在这方面同样大量移植boost:

std:;mutex

std::unique_lock

std::condition_variable

它们让多线程共用全局posix互斥锁、条件变量的方式成为历史

std::unique_lock和std::condition_variable,基本对应boost的scoped_lock和condition_variable,使用方法完全一样

以线程池的部分实现为例:

1、首先声明和定义线程池的执行实体:

  1. using Task = std::function<void ()>;
  2. struct Timertask {
  3. bool flag_;
  4. Task task_;
  5. int64_t timeval_;
  6. int64_t exec_time_;
  7. bool operator< (const struct Timertask otherone) const {
  8. return exec_time_ > otherone.exec_time_;
  9. }
  10. Timertask(const Task &task, int64_t timeval, int64_t exec_time, bool flag = false):flag_(flag), task_(task), timeval_(timeval), exec_time_(exec_time) {}
  11. Timertask(const Task &task, int64_t timeval, bool flag = false):flag_(flag), task_(task), timeval_(timeval) {
  12. int64_t nowtime = common::getime_micros();
  13. exec_time_ = timeval_ + nowtime;
  14. }
  15. };

业务上包括任务Task、和定时任务Timertask两类,执行实体都是Task

Timertask重载<是因为定时任务需要按时间临的远近排序,线程池的定时任务队列的实现是一个堆,所以这里需要重载<;flag_意为是一次性定时任务还是例行定时任务。

这些非本部分关注点不影响阅读即可。

2、线程池的声明,重点关注多线程互斥锁、条件变量成员

  1. class ThreadPool {
  2. private:
  3. std::atomic<uint64_t> pending_num_;
  4. std::atomic<uint64_t> running_num_;
  5. uint64_t task_count_;
  6. bool stop_;
  7. int thread_num_;
  8. std::vector<std::thread> ths_;
  9. std::mutex mtx_;
  10. std::condition_variable cond_;
  11. std::deque<Task> queue_;
  12. std::priority_queue<Timertask> timer_queue_;
  13. public:
  14. ThreadPool(int thread_num);
  15. ~ThreadPool();
  16. bool Start();
  17. bool Stop(bool graceful);
  18. void AddTask(const Task &task);
  19. void AddPriorityTask(const Task &task);
  20. void AddDelayTask(int timeval, const Task &task);
  21. void AddTimerTask(int timeval, const Task &task);
  22. bool IsEmpty() {return (running_num_ > 0)?false:true;}
  23. bool CancelTask();
  24. static void *ThreadFunc(void *arg) {
  25. reinterpret_cast<ThreadPool *>(arg)->process();
  26. return 0;
  27. }
  28. void process();
  29. };

3、线程池构造与析构

重点关注析构,析构函数在"优雅模式"下,可以通过原子成员变量pending_num_获知是否全部任务执行完毕

非优雅模式下,首先置stop_标志位为false意为即将析构,并通过条件变量cond_的notify_all唤醒全部线程,使其执行完当前任务后退出

  1. bool ThreadPool::Start () {
  2. std::unique_lock<std::mutex> lock(mtx_);
  3. stop_ = false;
  4. for (auto i: common::Range(0, thread_num_)) {
  5. ths_.push_back(std::thread(&ThreadFunc, this));
  6. }
  7. }
  8. bool ThreadPool::Stop (bool graceful) {
  9. if (graceful) {
  10. while (pending_num_) {
  11. std::chrono::milliseconds duration(5000);
  12. std::this_thread::sleep_for(duration);
  13. }
  14. }
  15. stop_ = true;
  16. cond_.notify_all();
  17. for (auto i: common::Range(0, thread_num_)) {
  18. ths_[i].join();
  19. }
  20. pending_num_ = running_num_ = task_count_ = 0;
  21. }

线程池的线程的实际执行函数,在执行完当前任务后会发现stop_标志位已经为false了,会纷纷退出

每个线程被操作系统调度到后,首先霸占互斥锁,注意c++11的互斥锁使用方法;

然后从任务队列中取出任务,然后释放掉互斥锁,自己去执行任务;如果没有任务,释放锁并一直等待条件变量的被通知

  1. void ThreadPool::process () {
  2. while (1) {
  3. std::unique_lock<std::mutex> lock(mtx_);
  4. while (timer_queue_.empty() && queue_.empty() && !stop_) {
  5. cond_.wait(lock);
  6. }
  7. if (stop_) {
  8. break;
  9. }
  10. if (!timer_queue_.empty()) {
  11. int64_t nowtime = common::getime_micros();
  12. Timertask newestask = timer_queue_.top();
  13. if (newestask.exec_time_ <= nowtime) {
  14. timer_queue_.pop();
  15. Task task = newestask.task_;
  16. bool flag = newestask.flag_;
  17. int64_t timeval = newestask.timeval_;
  18. if (flag) {
  19. Timertask newtask(task, timeval, true);
  20. timer_queue_.push(newtask);
  21. ++task_count_;
  22. }
  23. ++running_num_;
  24. --pending_num_;
  25. lock.unlock();
  26. task();
  27. lock.lock();
  28. --running_num_;
  29. }
  30. }
  31. if (!queue_.empty()) {
  32. Task task = queue_.front();
  33. queue_.pop_front();
  34. --pending_num_;
  35. ++running_num_;
  36. lock.unlock();
  37. task();
  38. lock.lock();
  39. --running_num_;
  40. }
  41. }

当给线程池加入新的要执行的任务,也会先霸占锁并向任务队列里加入新的任务,然后通知某一个正在等待条件变量同步的sleeping的线程(notify_one):

普通任务以双向数组std::deque管理,按是否重要选择前插还是后插

    1. void ThreadPool::AddTask (const Task &task) {
    2. std::unique_lock<std::mutex> lock(mtx_);
    3. queue_.push_back(task);
    4. ++pending_num_;
    5. ++task_count_;
    6. cond_.notify_one();
    7. }
    8. void ThreadPool::AddPriorityTask (const Task &task) {
    9. std::unique_lock<std::mutex> lock(mtx_);
    10. queue_.push_front(task);
    11. ++pending_num_;
    12. ++task_count_;
    13. cond_.notify_one();
    14. }
    15. void ThreadPool::AddDelayTask (int timeval, const Task &task) {
    16. std::unique_lock<std::mutex> lock(mtx_);
    17. Timertask newtask(task, timeval);
    18. timer_queue_.push(newtask);
    19. ++task_count_;
    20. cond_.notify_one();
    21. }
    22. void ThreadPool::AddTimerTask (int timeval, const Task &task) {
    23. std::unique_lock<std::mutex> lock(mtx_);
    24. Timertask newtask(task, timeval, true);
    25. timer_queue_.push(newtask);
    26. ++task_count_;
    27. cond_.notify_one();
    28. }

http://blog.csdn.net/u010246947/article/details/77822972

http://blog.csdn.net/u012931582/article/details/61655729

http://blog.csdn.net/zhangyifei216/article/details/72868345

c++11新特性总结(转。加上重点)的更多相关文章

  1. C++11新特性总结 (二)

    1. 范围for语句 C++11 引入了一种更为简单的for语句,这种for语句可以很方便的遍历容器或其他序列的所有元素 vector<int> vec = {1,2,3,4,5,6}; ...

  2. C++11新特性总结 (一)

    1. 概述 最近在看C++ Primer5 刚好看到一半,总结一下C++11里面确实加了很多新东西,如果没有任何了解,别说自己写了,看别人写的代码估计都会有些吃力.C++ Primer5是学习C++1 ...

  3. [转载] C++11新特性

    C++11标准发布已有一段时间了, 维基百科上有对C++11新标准的变化和C++11新特性介绍的文章. 我是一名C++程序员,非常想了解一下C++11. 英文版的维基百科看起来非常费劲,而中文版维基百 ...

  4. C++11新特性应用--实现延时求值(std::function和std::bind)

    说是延时求值,注意还是想搞一搞std::function和std::bind. 之前博客<C++11新特性之std::function>注意是std::function怎样实现回调函数. ...

  5. C++11新特性— auto 和 decltype 区别和联系

    一. auto简介 编程时候常常需要把表达式的值付给变量,需要在声明变量的时候清楚的知道变量是什么类型.然而做到这一点并非那么容易(特别是模板中),有时候根本做不到.为了解决这个问题,C++11新标准 ...

  6. c++ 11 线程池---完全使用c++ 11新特性

    前言: 目前网上的c++线程池资源多是使用老版本或者使用系统接口实现,使用c++ 11新特性的不多,最近研究了一下,实现一个简单版本,可实现任意任意参数函数的调用以及获得返回值. 0 前置知识 首先介 ...

  7. C++ 11学习和掌握 ——《深入理解C++ 11:C++11新特性解析和应用》读书笔记(一)

    因为偶然的机会,在图书馆看到<深入理解C++ 11:C++11新特性解析和应用>这本书,大致扫下,受益匪浅,就果断借出来,对于其中的部分内容进行详读并亲自编程测试相关代码,也就有了整理写出 ...

  8. C++ 11 新特性

    C++11新特性:          1.auto          2.nullptr          3.for          4.lambda表达式          5.override ...

  9. 在C++98基础上学习C++11新特性

    自己一直用的是C++98规范来编程,对于C++11只闻其名却没用过其特性.近期因为工作的需要,需要掌握C++11的一些特性,所以查阅了一些C++11资料.因为自己有C++98的基础,所以从C++98过 ...

  10. C++11新特性——range for

    很多编程语言都有range for语法功能,自C++11起,终于将这个重要功能加入C++标准中.range for语句,可以方便的遍历给定序列中的每个元素并对其执行某种操作. 1.基本语法 for(d ...

随机推荐

  1. 实战zabbix3.0.2 使用percona mysql插件监控mysql5.7

    1.系统环境 [root@shard0 templates]# cat /etc/redhat-release Red Hat Enterprise Linux Server release 7.2 ...

  2. Shadow Mapping 的原理与实践 【转】

    早在上世纪七十年代末,Williams在他的“Casting Curved Shadows on Curved Surface”一文中提出了名为Shadow Map的阴影生成技术.之后,他人在此基础上 ...

  3. TCP/IP知识总结(TCP/IP协议族读书笔记一)

    一.简述TCP/IP协议 Transmission Control Protocol/Internet Protocol的简写,即传输控制协议/互联网互联协议,又名网络通信协议.是Internet最基 ...

  4. Fundamentals of Garbage Collection

    [Fundamentals of Garbage Collection] 1.Reclaims objects that are no longer being used, clears their ...

  5. go_Map

    go语言中map使用哈希表,必须可以比较相等 除了slice,map,function的内建类型都可以作为key Struct类型不包括上述字段,也可作为key map中的key是无序的 packag ...

  6. 判断viewpager左右滑动方向

    实现思路就是通过viewpager的滑动监听,用参数position进行比较,同时当判断完这个要把比较的positon覆盖.这里简单介绍一下public void onPageScrolled(int ...

  7. 判断单选框选中不成功,$("#xx").attr("checked")undefined

    判断单选框选中状态,各种都不行,受到https://www.cnblogs.com/yxwkf/p/4853014.html 的启发,相关引用: 原来.在jquery1.6版本号便对此做出了改动: [ ...

  8. Halcon中xld的常见特征的含义总结

    如下图:

  9. Golang基本结构之练习(day2)

    笔记: . 任何一个代码文件隶属于一个包 . import 关键字,引用其他包: import(“fmt”) import(“os”) 通常习惯写成: import ( “fmt” “os” ) . ...

  10. 转载:Candy? 在线性时间内求出素数与欧拉函数

    转载自:http://www.cnblogs.com/candy99/p/6200660.html 2818: Gcd Time Limit: 10 Sec  Memory Limit: 256 MB ...