C++ on 子恒的博客

[C++]C++ 11/14 笔记（四）

Tue, 18 Aug 2020 19:34:11 +0800

本部分介绍了c++11的并发编程。这些笔记是未完成的。

语法参考这里：
现代C++教程
实现参考这里：
C++11中的mutex, lock，condition variable实现分析

std::thread

C++ 11为我们带来了语言级的线程支持，包括线程的创建和等待：

//g++ -o t main.cpp -lpthread --std=c++11
#include <iostream>
#include <thread>
#include <chrono>

void foo(int sec)
{
    // sleep_for() 休眠sec秒后唤醒
    std::this_thread::sleep_for(std::chrono::seconds(sec));
}

int main()
{
    // join() 阻塞等待线程
    // joinable() 是否可以join（没设置任务函数不可以join）
    std::thread t;
    std::cout << "before starting, joinable: " << t.joinable() << '\n';
    t = std::thread(foo, 1);
    std::cout << "after starting, joinable: " << t.joinable() << '\n';
    t.join();

    // detach() 将当前线程对象所代表的执行实例与该线程对象分离，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。
    // 永远不要用detach()。失去控制的线程会有很多问题
    // get_id() 打印线程id
    std::thread t1(foo, 2);
    std::thread::id t1_id = t1.get_id();
    std::cout << "t1_id: " << t1_id << '\n';
    t1.detach();
}

std::mutex和std::lock_guard同步

有了线程就必然需要锁。我们看一个例子，用RAII 的方式管理线程和锁：

[Linux]GDB调试技巧

Sun, 17 Dec 2017 00:56:18 +0800

命令行参数

gdb有下面几种运行方式：

// 1. 通过coredump文件，或者存在的进程id分析，不会拉起新进程
gdb [options] [executable-file [core-file or process-id]]
// 2. 带参数运行程序
gdb [options] --args executable-file [inferior-arguments ...]
// 3. redhat等含有用于调试python的工具
// gdb [options] [--python|-P] script-file [script-arguments ...]

几个值得注意的参数：

// 和上面的类似，使用参数指定的
--args             Arguments after executable-file are passed to inferior
--core=COREFILE    Analyze the core dump COREFILE.
--pid=PID          Attach to running process PID.
--exec=EXECFILE    Use EXECFILE as the executable.
// 远程调试
-b BAUDRATE        Set serial port baud rate used for remote debugging.
-l TIMEOUT         Set timeout in seconds for remote debugging.
// 运行某个文件中的gdb指令
--command=FILE, -x Execute GDB commands from FILE.
// 运行某gdb指令，如gdb a.out -ex r开启文件并立即运行
--eval-command=COMMAND, -ex   Execute a single GDB command.
--directory=DIR    Search for source files in DIR.
--se=FILE          Use FILE as symbol file and executable file.

简单的例子：coredump分析

gdb的一大用处是通过coredump文件分析程序哪里发生了错误。首先要打开coredump生成开关：

[C++]sizeof那些事儿

Wed, 16 Aug 2017 23:33:20 +0800

sizeof 是什么

首先明确一点，sizeof是运算符，不是函数。运算符是一个对于编译器来说的概念，是由编译器处理的，在程序编译好之后所有的sizeof都已经被替换为实际的值。类似的还有decltype。所以像

`1`	`sizeof(++i);`

这类的语句是不会改变i的值的。在C99之后，sizeof增加了一些运行时特性，可以算出可变数组的大小，像这样：

int num;
scanf("%d", &num);	 //input 4
int arr[num];
sizeof(arr);		//output 16

sizeof 怎么用

sizeof 支持下面的语法：

1
2

sizeof(type) 	    (1) 以字节数返回type类型对象表示的大小 
sizeof expression 	(2) 以字节数返回expression的类型对象表示的大小

其中，sizeof(char)、 sizeof(signed char)以及sizeof(unsigned char)始终返回1。

sizeof不能用于函数类型、不完整类型（含void）或位域左值。在一些编译器里，sizeof(void)会返回0，但这是没有定义的。

普通的sizeof

几个上面用法的例子：

int main(void)
{
    // type argument:
    printf("sizeof(float)         = %u\n", sizeof(float));   //4
    printf("sizeof(void(*)(void)) = %u\n", sizeof(void(*)(void)));   //4
    printf("sizeof(char[10])      = %u\n", sizeof(char[10]));    //10

    // expression argument:
    printf("sizeof 'a'   = %u\n", sizeof 'a'); // 'a'的类型是int, 4
//  printf("sizeof main = %zu\n", sizeof main); // 错误：函数类型
    printf("sizeof &main = %u\n", sizeof main()); //类型为返回值int, 4
    printf("sizeof \"hello\" = %u\n", sizeof "hello"); // 类型为char[6], 6
    printf("sizeof(\"12345\" + 1)     = %u\n", sizeof("12345" + 1)); // 类型为指针, 4
}

需要注意的是，在函数传参等数组退化为指针的时候sizeof返回的当然是指针大小，切忌用它来计算数组大小。

[C++]C++ 100行实现线程池

Fri, 07 Apr 2017 23:17:54 +0800

一个100行左右的简单线程池。用到了std::mutex和std::thread等新特性。

线程池模型

首先把每个函数抽象为一个任务(Task)，任务的过程就是调用这个Task的run函数。
然后把线程池中的线程封装为一个线程类（Thread），一直等待调度器分配任务（空闲状态），如果有任务分配立即进入忙状态。等任务执行结束再次变为空闲状态。
最后是一个调度器类（TreadPool），包含任务队列（随时添加新任务），和一个包含了Thread的vector（线程池中的线程）。如果任务队列非空，调度器每次从中取出一个任务，然后轮询线程池，搜寻空闲线程并把这个任务交给线程。
模型如下图所示：

代码实现

下面的代码实现了上述模型。其中Task类通过睡眠一定的秒数模拟任务，可以看到T1先执行完毕（1秒完毕），T2和T3在之后同时完毕，说明调度非常成功。

//linux, g++ -std=c++14 -o t *.cpp -pthread
#include <queue>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <unistd.h> 

class Task{
private:
    int no;
public:
    Task(int n){
        no = n;
    }
    //可以继承这个类重写该方法执行任务
    virtual void run(){
        sleep(no); //构造时决定执行几秒，模拟线程运行
        std::cout << no << "T\n";
    }

};

class Thread{
private:
    std::thread _thread;
    bool _isfree;
    Task *_task;
    std::mutex _locker;
public:
    //构造
    Thread() : _isfree(true), _task(nullptr){
        _thread = std::thread(&Thread::run, this);
        _thread.detach(); //放到后台， join是等待线程结束
    }
    //是否空闲
    bool isfree(){
        return _isfree;
    }
    //添加任务
    void add_task(Task *task){
        if(_isfree){
            _locker.lock();
            _task = task;
            _isfree = false;
            _locker.unlock();
        }
    }
    //如果有任务则执行任务，否则自旋
    void run(){
        while(true){
            if(_task){
                _locker.lock();
                _isfree = false;
                _task->run();
                _isfree = true;
                _task = nullptr;
                _locker.unlock();
            }
        }
    }

};

class ThreadPool{
private:
    std::queue<Task *> task_queue;
    std::vector<Thread *> _pool;
    std::mutex _locker;

public:
    //构造线程并后台执行，默认数量为10
    ThreadPool(int n = 10){
        while(n--){
            Thread *t = new Thread();
            _pool.push_back(t);
        }
        std::thread main_thread(&ThreadPool::run, this);
        main_thread.detach();
    }
    //释放线程池
    ~ThreadPool(){
        for(int i = 0;i < _pool.size(); ++i){
            delete _pool[i];
        }
    }
    //添加任务
    void add_task(Task *task){
        _locker.lock();
        task_queue.push(task);
        _locker.unlock();
    }
    //轮询
    void run(){
        while(true){
            _locker.lock();
            if(task_queue.empty()){
                _locker.unlock();
                continue;
            }
            // 寻找空闲线程执行任务
            for(int i = 0; i < _pool.size(); ++i){
                if(_pool[i]->isfree()){
                    _pool[i]->add_task(task_queue.front());
                    task_queue.pop();
                    break;
                }
            }
            _locker.unlock();
        }
    }

};

int main(){
    ThreadPool tp(2);
    
    Task t1(1);
    Task t2(3);
    Task t3(2);

    tp.add_task(&t1);
    tp.add_task(&t2);
    tp.add_task(&t3);
    
    sleep(4);   //等待调度器结束，不然会崩溃
    return 0;
}

[C++]C++多线程基础

Mon, 03 Apr 2017 13:58:53 +0800

各种锁的基本概念以及在C++里的使用，还有C的一个生产消费模型。

操作系统的知识

概念

临界区：访问和操作共享数据的代码段
避免死锁：嵌套加锁时按顺序加锁, 防止发生饥饿

原子操作：atomic_t

自旋锁

自旋锁：请求该锁的线程在等待时自旋（特别耗费处理器时间），所以只能轻量级加锁（一般锁的时间小于上下文切换的开销）。
注意：对数据而不是对代码加锁。

读写自旋锁：读时(允许读，不允许写)，写时（不允许读，不允许写）。
注意：不能把读锁升级为写锁，不然会死锁。读写操作要清晰地分开。

信号量

信号量：请求锁的进程在等待时加入等待队列并睡眠。一般用于长时间加锁（唤醒、睡眠、加入队列都是很大的开销）。
通过P/V或者down()/up()操作来控制允许同时进行的线程数。信号量减一就等同与获取一个锁，锁为负数时线程就会进入等待队列。
0/1信号量（互斥信号量）：只允许同时一个线程执行。
计数信号量：允许同时多个线程执行。
读写信号量：互斥信号量的一种。

互斥体

互斥体(mutex): 可以睡眠的强制互斥锁。比信号量更加首选。

mutex和自旋锁的区别：

需求	加锁方法
低开销加锁	优先自旋锁
短期加锁	优先自旋锁
长期加锁	优先mutex
中断上下文加锁	只能自旋锁
持有锁时需要睡眠	只能mutex

C++11 的线程库

std::thread

std::thread用于创建一个执行的线程实例，所以它是一切并发编程的基础，使用时需要包含头文件，它提供了很多基本的线程操作，例如get_id()来获取所创建线程的线程 ID，例如使用join()来加入一个线程等。

std::mutex, std::unique_lock, std::lock_guard

使用std::mutex创建互斥体，std::unique_lock上锁。由于C++保证了所有栈对象在声明周期结束时会被销毁，所以这样的代码是异常安全的。无论发生异常还是正常结束，都会自动调用unlock()。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void block_area() {
    std::unique_lock<std::mutex> lock(mtx);
    //...临界区
}
int main() {
    std::thread thd1(block_area);
    thd1.join();

    return 0;
}

C加锁示例：生产/消费模型

需求是两个进程维护一片共享内存，里面存十个产品（抽象为长度为10的一个循环队列）。生产者负责生产产品，注意队列满了就不能生产了，这时候进程陷入沉睡；消费者负责消费产品，消费完了队列的产品之后也要陷入沉睡。
Linux端代码如下：

[C++]C++ 11/14 笔记（三）

Mon, 30 Jan 2017 23:25:54 +0800

本部分介绍了c++11的容器、智能指针和正则。

std::array

代替原来的c数组，提供了size()，empty()，大小比较以及迭代器。
注意：

声明的第二个模板参数必须是编译期常量
不能隐式转换为指针，调用data()返回c数组地址

std::array<int,4> arr = {1,2,3,4};

// C 风格接口传参
// foo(arr, arr.size());           // 非法, 无法隐式转换
foo(&arr[0], arr.size());
foo(arr.data(), arr.size());

// 使用 `std::sort`
std::sort(arr.begin(), arr.end());

std::forward_list

单向实现的列表，提供了O(1)的插入，并且比双向更省空间。

无序容器

传统 C++ 中的有序容器 std::map/std::set，这些元素内部通过红黑树进行实现，插入和搜索的平均复杂度均为 O(log(size))。在插入元素时候，会根据 < 操作符比较元素大小并判断元素是否相同，并选择合适的位置插入到容器中。当对这个容器中的元素进行遍历时，输出结果会按照 < 操作符的顺序来逐个遍历。

而无序容器中的元素是不进行排序的，内部通过 Hash 表实现，插入和搜索元素的平均复杂度为 O(constant)，在不关心容器内部元素顺序时，能够获得显著的性能提升。

C++11 引入了两组无序容器：std::unordered_map, std::unordered_multimap 和std::unordered_set, std::unordered_multiset。

它们的用法和原有的std::map/std::multimap/std::set/set::multiset基本类似。

std::tuple

提供了N元组的数据结构。
该数据结构在cpp14中还不够完善。

智能指针

在传统 C++ 里我们使用 new 和 delete 去『记得』对资源进行释放。而 C++11引入了智能指针的概念，使用了引用计数的想法，让程序员不再需要关心手动释放内存。这些智能指针包括 std::shared_ptr/std::unique_ptr/std::weak_ptr，使用它们需要包含头文件 <memory>。

[C++]C++ 11/14 笔记（二）

Sun, 29 Jan 2017 23:25:54 +0800

本部分介绍了c++11的Lambda、函数容器和右值引用。

Lambda

结构：

1
2
3

[捕获列表](参数列表) -> 返回类型{
    // 函数体
}

比如定义一个加法的lambda：

auto add = [](auto x, auto y) {
    return x+y;
};
add(1.0, 2.3);

捕获列表用于传递外部的变量，分为以下几种：

[] 空捕获列表
[name1, name2, …] 捕获一系列变量
[=] 值捕获, 捕获的变量为lambda表达式被创建时的值
[&] 引用捕获, 值会发生变化

函数容器

std::function

函数的类型安全的容器。比如下面的std::function<int(int)> func2定义了一个返回值int,参数为(int)的一个函数对象。其中捕获列表是传引用的，所以返回的是调用func2时的1+value+important的值。

int important = 10;
std::function<int(int)> func2 = [&](int value) -> int {
    return 1+value+important;
};

std::bind/std::placeholder

有点像python的偏函数，它给函数一些预定的参数，以便于用更少的参数调用：

int foo(int a, int b, int c) {
    return a + b + c;
}
int main() {
    // 将参数1,2绑定到函数 foo 上，但是使用 std::placeholders::_1 来对第一个参数进行占位
    auto bindFoo = std::bind(foo, std::placeholders::_1, 1,2);
    // 这时调用 bindFoo 时，只需要提供第一个参数即可
    bindFoo(1);
}

右值引用

右值和左值

以赋值符号为界，左面的表示一个对象，右面的表示一个对象的值

[C++]C++ 11/14 笔记（一）

Fri, 20 Jan 2017 10:15:13 +0800

本部分介绍了c++11的崭新的类型推导、循环、模板和构造方法。

弃用的特性

1.　不允许以下赋值出现，应使用const char *后者auto。

`1`	`char *str = "hello world!";`

2.　C语言风格的类型转换被弃用，应该使用 static_cast、reinterpret_cast、const_cast 来进行类型转换
3.　register， auto_ptr关键字被弃用。

语言增强

新的关键字

使用nullptr而不是NULL。新的nullptr为nullptr_t类型，可以隐式转换为任何类型，同时避免了NULL == 0这种类型冲突。
constexpr函数：告诉编译器返回的值为常量表达式

类型推导

auto类型

auto型可以作为变量的声明类型，函数的返回类型
auto型作为函数参数在c++17中才可使用，但要注意重载的问题
auto不能用于数组的类型推导
迭代器的样例：

`1`	`for(auto itr = vec.cbegin(); itr != vec.cend(); ++itr);`

decltype函数

返回值为一个类型。比如我们可以把z声明为推测的类型

`1`	`decltype(x+y) z = x + y;`

for(item:array)循环

像Python一样地迭代：

std::vector<int> arr(5, 100);
// & 启用了引用, 如果没有则对 arr 中的元素只能读取不能修改
for(auto &i : arr) {
    std::cout << i << std::endl;
}

初始化列表

除了

拷贝构造
() 构造函数初始化
加入了使用列表来初始化的特性：

class Magic {
public:
    Magic(std::initializer_list<int> list) {}
};

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

模板的强化

关键字

外部模板extern template推迟模板的实例化
>>不再只是右移运算符，可以视作括号嵌套：

`1`	`std::vector<std::vector<int>> wow;`

using提供的类型别名

using提供了以下的别名：