早在19年5月就在某站上看到sylar的视频了，一直认为这是一个非常不错的视频，由于本人一直是自学编程，基础不扎实，也没有任何人的督促，没能坚持下去，每每想起倍感惋惜。恰逢互联网寒冬，在家无事，遂提笔再续前缘。

为了能更好的看懂sylar，本套笔记会分两步走，每个系统都会分为两篇博客。
分别是【知识储备篇】和【代码分析篇】
(ps:纯粹做笔记的形式给自己记录下，欢迎大家评论，不足之处请多多赐教)
QQ交流群：957100923

---

协程模块-知识储备篇

知识点01： 理解【void** array = (void**)malloc(sizeof(void*) * size);】

背景：

在sylar中有这么一行代码：void** array = (void**)malloc(sizeof(void*) * size);你理解它的含义吗？
我敢说大部分人其实并不理解，甚至有部分工作几年的可能只是：“会用！但是没有深思过。”
屏幕前的你觉得该如何解释以上代码呢？

由于此知识点比较多，以下是我为解释这行代码所做的准备。
后面的知识你可能会觉得有点突兀，但是我希望你能看下去。
正如学习方法一样：
1.有些人会用倒推法学习，从表象一层一层往里剥。
2.有些人会用公式法学习（比如化学，将最基本的物理现象抽象成化学现象，再抽象成公式学习，这其实很适合当今应试教育的大环境）
3.我属于愚公类型，喜欢从最原始的往上学（这其实对于当今应试教育环境下是比较吃亏的）

---

1.【名词】与【动词】：

先要解释一下什么是【名词】，什么是【动词】：
【名词】主要表示人、事物、地点或抽象概念的名称。
【动词】则表示人或事物的动作、存在或变化。

举几个例子：
【名词】：歌曲、舞蹈、篮球…
【动词】：唱、跳、rap、打篮球…

---

2.【int a = 1;】是【名词】还是【动词】？

1.大部分人都会说：有一个值为1的整型变量a。【名词】
2.少部分人会说：让计算机在栈空间上，开辟一块名称为a，大小为sizeof(int)个字节的空间，将这块空间的值设置为1。【动词】

显然1号说法将int a = 1;看做一个【名词】，理解上是不深刻的。2号说法起码将其理解为【动词】了，而且有了内存堆栈的概念了，但是描述的依旧很欠缺，不能描述a的存在，CPU不知道什么是名称为a，CPU只知道具体地址。

3.我说：int a = 1;首先对于计算机来说这是一个动作，所以是【动词】。
其次我们写的是C++语言，是写给C++编译器看的，不是直接给CPU下达指令的。

所以这行代码的解释：
告诉编译器，请将字符a与一个栈内存的地址，假设是：[0x986FA]绑定映射关系，
让CPU在内存地址为[0x986FA]后面开辟4或8个字节的空间，(具体字节数是多少比较复杂，后面解释)
将这段内存的值设置为1。

总结：
很明显，我们面向的是C++编译器，这样就能解释a的存在了，因为编译器会将a和对应地址做映射。
很多人说 a就是地址，却一直不解释为什么，而我就是因此困扰了好多年。
(ps:本人属于不太聪明的一类人，以上问题确实困扰了我好多年，如今的解释也只是如今的解释。)

---

3.内存地址的最大表示范围是多少？（一条街上最多能有几个门牌号，门牌号设计成百位还是千位还是更高？）

要确定内存地址的最大表示范围，我们就要了解CPU和内存之间是怎么交互的。

首先CPU与内存交互需要三个总线分别是：【控制总线】【地址总线】【数据总线】。
【控制总线】的作用：告诉CPU是读取内存的操作还是写入内存的操作。
【地址总线】的作用：告诉CPU要操作的内存地址。
【数据总线】的作用：CPU一次数据传输能传输的最大信息。

何为总线？总线就是由若干根线捆在一起就叫总线。
如果说一根电线根据通电断电能表示0和1,那么他最多能展示2种状态。
如果有两根线，那么他最大能表示的状态就是2的2次方就是最多展示4个状态。
32根线就是2的32次方，就是4G，也就是最多展示4G个状态。
64根线就是2的64次方，就是17179869184G，也就是最多展示这么多的状态。

所以如果【地址总线】由32根电线捆成一股，那么他就最多能给内存编2的32次方=4G个号码牌（内存地址）。
如果【数据总线】由32根电线捆成一股，那么他就能一次给CPU传输32个电信号。

CPU内部有许多寄存器，寄存器是用来存放准备运算的数据的，寄存器的大小决定了CPU每次运算能处理的最大信息。
也就是如果一个寄存器有32个格子，那么他一次能处理32位的数据，也就是4字节的数据。

好！我们描述一下CPU从内存读取数据的流程：
1.控制总线告诉CPU当前是从内存取数据的操作
2.地址总线将地址信息传递给CPU，告诉它要取的数据在内存中的地址
3.CPU将对应地址编号存储到对应寄存器中，然后进行取数据的操作
4.CPU通过数据总线将数据从内存中获取到，并将数据放到对应寄存器中用于后续的运算

了解完以上信息后我们再来谈一个地址的大小是由谁决定的？注意我这里说的是地址的大小，不是指针哦。
如果CPU要从内存中取一个数据，那么CPU需要通过地址总线获取到地址：
1.如果CPU中寄存器是32位的，地址总线也有32根，那么OK刚刚好，地址总线一次传递的信息就能正好让一个寄存器接收，那么一个地址的大小就是32位也就是4个字节。
2.如果寄存器是64位的但是地址总线只有32根，那么一次传递的信息也就只有32位，所以一个地址的大小依旧是32位也就是4个字节。
所以内存地址的最大表示范围在目前看来只需要考虑CPU内寄存器的大小和地址总线的大小，两者取小的就行。
但是如果有以下使用指针的情况：

int a = 1;
int* p = &a;

我们站在C++编译器的角度来看，这两行代码大致会有以下操作：
0.假设我们现在一个int大小是8个字节（就是64位）。
1.在栈内存中开辟8个字节的空间，假设起始地址是[0x09FA]
2.将这段内存的内容设置为1（也就是31个0和一个1）
3.将字符’a’与[0x09FA]绑定映射关系
4.将字符’a’打上int类型标签
5.在栈内存中开辟8个字节的空间，假设起始地址是[0x08FB]
6.将这段内存的内容设置为 0x09FA （也就是变量a的地址起始编号）
7.将字符’p’与[0x8FB]绑定映射关系
8.将字符’p’打上int*类型的标签

我们站在CPU的角度来看，这两行代码大致会有以下操作：
先转换为汇编：

mov dword ptr [a], 1   ; 初始化变量a
lea eax, [a]           ; 将x的地址加载到eax寄存器
mov dword p [p], eax   ; 将eax寄存器的内容（即a的地址）存储到p中

0.假设现在寄存器大小和数据总线根数和地址总线根数一致都是64位也就是8字节
1.控制总线标记现在为写入操作
2.CPU通过地址总线找到地址内存地址[0x09FA]
3.CPU通过数据总线将数字1传送到对应地址，覆盖内容
4.控制总线标记现在为写入操作
5.CPU根据地址总线获取到要读取的内存地址[0x08FB]
6.CPU通过数据总线将数据0x09FA写入到地址为[0x08FB]的内存中

通过以上步骤分析，特别是站在CPU角度看，第5和第6步可以看出，数据总线会将表示地址的数据传递到指定内存中。所以在使用指针的情况下，数据总线也将参与地址的传递。

总结：内存地址的最大表示范围 和【数据总线】、【地址总线】、【寄存器】的位数息息相关！他们的最小值确定了 内存地址的位数，也就确定了该环境下指针的大小

---

4.分析【int* array = (int*)malloc(sizeof(int) * 10);】

在知道指针大小(内存地址位数)是如何计算的之后，我们来看这行代码。
0.在c++中，指针的大小和int类型的大小是一样的
1.使用malloc分配了10个大小为int大小的空间
2.由于malloc是直接调用系统的内存分配方法，所以没有对应的类型标记，所以需要强制转换类型为int*
3.所以这里相当于分配了一个数组，该数组中的每一个值都表示一个int类型。

---

5.分析【void** array = (void**)malloc(sizeof(void*) * 10);】

分析这行代码的时候，其实只要替换4中的 int 为 void* 就可以了，void表示无类型，*表示指针类型。
所以这里相当于分配了一个数组，该数组中的每个值都表示一个内存地址。

---

6.知识点01总结

以上弯弯绕绕一大堆，多少有些跑题，但是C++就是这样，不清楚指针的时候代码中任何一个"*"符号就会阻碍你的理解。
要想读懂代码，就要搞明白指针。
想要搞明白指针，就要搞清楚内存地址。
想要搞清楚内存地址，就要搞清楚CPU是如何操作内存的。
要想搞清楚CPU是如何操作内存的，就要搞清楚【寄存器】、【数据总线】、【地址总线】、【控制总线】的关系。
这里也是泛泛而谈，有机会我会详细的出一个【汇编系列】。

---

知识点02：【backtrace】

在Linux上的C/C++编程环境下，我们可以通过如下三个函数来获取程序的调用栈信息。

#include <execinfo.h>
 
/* Store up to SIZE return address of the current program state in
   ARRAY and return the exact number of values stored.  */
int backtrace(void **array, int size);
 
/* Return names of functions from the backtrace list in ARRAY in a newly
   malloc()ed memory block.  */
char **backtrace_symbols(void *const *array, int size);
 
/* This function is similar to backtrace_symbols() but it writes the result
   immediately to a file.  */
void backtrace_symbols_fd(void *const *array, int size, int fd);

---

知识点03：【std::atomic】

在多线程（协程）编程中，当多个线程（协程）同时访问同一块数据时，可能会导致数据竞争和不确定的行为。
举例：

#include <iostream>
#include <thread>
#include <mutex>
 
int counter = 0;
 
void incrementCounter(){
    for (int i = 0; i < 100000; ++i){
        counter++;
    }
}
 
int main(int argc, char** argv){
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);
 
    t1.join();
    t2.join();
 
    std::cout << counter << std::endl;
 
    return 0;
}

可以看到以下输出：

140418

在线程模块中我们有遇到过这个情况，我们的处理方式就是加锁。例如：

int counter = 0;
std::mutex mutex;
 
void incrementCounter(){
    for (int i = 0; i < 100000; ++i){
        std::lock_guard<std::mutex> lock(mutex);
        counter++;
    }
}
 
int main(int argc, char** argv){
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);
 
    t1.join();
    t2.join();
 
    std::cout << counter << std::endl;
 
    return 0;
}

以下是输出：

200000

当然也可以使用 std::atomic 来实现

#include <atomic>
 
std::atomic<int> counter(0);
 
void incrementCounter(){
    for (int i = 0; i < 100000; ++i)
    {
        counter++;
    }
}
 
int main(int argc, char** argv){
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);
 
    t1.join();
    t2.join();
 
    std::cout << counter << std::endl;
 
    return 0;
}

可以看到也能正确输出：

200000

---

知识点04：【ucontext】

在头文件< ucontext.h > 中
定义了两个结构类型，mcontext_t和ucontext_t
和四个函数：getcontext(),setcontext(),makecontext(),swapcontext()。
利用它们可以在一个进程中实现用户级的线程切换。

getcontext获取当前上下文

//初始化ucp结构体，将当前的上下文保存到ucp中

int getcontext(ucontext_t *ucp);

setcontext设置当前上下文

//设置当前的上下文为ucp，setcontext的上下文ucp应该通过getcontext或者makecontext取得，如果调用成功则不返回。
//如果上下文是通过调用getcontext()取得,程序会继续执行这个调用。
//如果上下文是通过调用makecontext取得,程序会调用makecontext函数的第二个参数指向的函数，
//如果func函数返回,则恢复makecontext第一个参数指向的上下文第一个参数指向的上下文context_t中指向的uc_link.
//如果uc_link为NULL,则线程退出。

int setcontext(const ucontext_t *ucp);

makecontext创建一个新的上下文

//makecontext修改通过getcontext取得的上下文ucp(这意味着调用makecontext前必须先调用getcontext)。
//然后给该上下文指定一个栈空间ucp->stack，设置后继的上下文ucp->uc_link.
//当上下文通过setcontext或者swapcontext激活后，执行func函数，argc为func的参数个数，后面是func的参数序列。
//当func执行返回后，继承的上下文被激活，如果继承上下文为NULL时，线程退出。

void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...);

swapcontext切换上下文

//保存当前上下文到oucp结构体中，然后激活upc上下文。
//如果执行成功，getcontext返回0，setcontext和swapcontext不返回；
//如果执行失败，getcontext,setcontext,swapcontext返回-1，并设置对于的errno.

int swapcontext(ucontext_t *oucp, ucontext_t *ucp);

ucontext实现的一个简单的例子：

#include <stdio.h>
#include <ucontext.h>
#include <unistd.h>
 
int main(int argc, const char** argv){
    ucontext_t context;
 
    getcontext(&context);
    puts("Hello world");
    sleep(1);
    setcontext(&context);
    return 0;
}

可以发现以下输出：

Hello world
Hello world
Hello world
Hello world
Hello world
Hello world
Hello world
^C

我们可以看到，程序在输出第一个“Hello world"后并没有退出程序，而是持续不断的输出”Hello world“。
其实是程序通过getcontext先保存了一个上下文,
然后输出"Hello world",
在通过setcontext恢复到getcontext的地方，
重新执行代码，所以导致程序不断的输出”Hello world“。
有点汇编中的jmp指令的味道。