Sylar C++高性能服务器学习记录06 【线程模块-代码分析篇】

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

为了能更好的看懂sylar，本套笔记会分两步走，每个系统都会分为两篇博客。

分别是【知识储备篇】和【代码分析篇】

(ps:纯粹做笔记的形式给自己记录下，欢迎大家评论，不足之处请多多赐教)

---

线程模块-代码分析

0.std::function & swap方法

有很多时候，很多知识是百度或者google都获取不到的，因为知识是变通的，网上搜索到的更多的是教学的基本知识。而往往你想要的是，工作经验积累后的知识。就好比你在大学学了C++，依旧看不懂Sylar一样。因为知识的运用绝对不是：学会基础后就能直接融会贯通的。这里我会举以下一个栗子🌰

---

0.1 如何交换两个方法：

#include <iostream>
#include <functional>

void func0(){
    std::cout << "This is func0 " << std::endl;
}

void func1(){
    std::cout << "This is func1" << std::endl;
}


int main(int argc, char** argv){
    std::function<void(void)> fa = func0;
    std::function<void(void)> fb = func1;

    std::cout << "====交换前====" << std::endl;
    fa();
    std::cout << "fa address: " << &fa << std::endl;
    fb();
    std::cout << "fb address: " << &fb << std::endl;

    //开始交换
    fa.swap(fb);

    std::cout << "====交换后====" << std::endl;
    fa();
    std::cout << "fa address: " << &fa << std::endl;
    fb();
    std::cout << "fb address: " << &fb << std::endl;

    return 0;
}

可以看到以下输出：

====交换前====
This is func0
fa address: 0x7fff20f52d90
This is func1
fb address: 0x7fff20f52db0
====交换后====
This is func1
fa address: 0x7fff20f52d90
This is func0
fb address: 0x7fff20f52db0

可以看到两个方法确实被交换了，但是方法的地址没有被交换。

很好理解，甚至我不需要解释，还是解释一下吧：

无论是方法还是属性，最终都将是10101010110这一类的二进制，没有任何区别，
那为什么计算机知道，哪些是数据，哪些是指令呢？
因为放在不同的区域，数据区的就是数据，代码区的就是指令。
一般来说我们交换两块内存中的内容指的是交换数据，也就是将两块处于数据段中的内容交换。
但是现在是将两块代码段中的内容进行交换，也就是计算机将代码段的指令当做是数据进行交换处理。
随后在调用方法时再次将交换后的内容当回代码段中的指令进行执行。
所以方法的地址没有改变，而指令却互换了。

如果还不能理解那我就换个说法，如下

如何理解属性和方法：

炒饭可以当名词，也可以当动词
菜单上写着【炒饭】，意思是这家店能提供【炒饭】这个食物。
菜谱上写着【炒饭】，意思是能教你【炒饭】的方法。
所以在不同地方【炒饭】指代的意思不同。

如何理解交换数据（属性）：

有两个盘子：A盘子放的是炒饭，B盘子放的是炒面
交换数据后：A盘子放炒面，B盘子放炒饭   
所以盘子没变，东西变了。

如何理解交换方法：

有两个文件夹：A文件夹中放着【炒饭的菜谱】，B文件夹中放着【炒面的菜谱】
交换方法（交换菜谱后）：A文件夹中放【炒面的菜谱】，B文件夹中放【炒饭的菜谱】
所以文件夹没变，菜谱变了。

好！当你不再困惑以上交换相关的知识之后，我们继续往下讲。

---

0.2 交换函数的巧妙思维与注意点

不是一定要AB两个文件夹都有菜谱才能交换。

我们可以用一个空文件夹和一个装有【炒饭菜谱】的文件夹进行内容交换。

有两个文件夹：A文件夹有【炒饭菜谱】，B文件夹是空的

交换后：A文件夹被清空了，B文件夹中装入了【炒饭菜谱】

可以看到我们间接的清空了A文件夹，所以swap函数除了能交换，其实也隐藏了转移的效果。

具体代码如下：

#include <iostream>
#include <functional>

//【炒饭】菜谱（这里方法定义的时候叫菜谱，调用的时候叫根据菜谱炒饭）
void func0(){
    std::cout << "炒饭中..." << std::endl;
}

int main(int argc, char** argv){
	//A文件夹装有【炒饭】菜谱
    std::function<void(void)> fa = func0;
    //B文件夹空着
    std::function<void(void)> fb;
    //将两个文件夹内容互换，也就是将A文件夹的炒饭菜谱转移到B文件夹中
	fb.swap(fa);
	//根据B文件夹中的【炒饭】菜谱，开始炒饭操作
	std::cout << "根据B文件夹中的【炒饭】菜谱，开始炒饭操作" << std::endl;
	fb();
	//此处因为上面的交换操作，导致A文件夹已经空了
	//！！！此处的调用好比是找不到菜谱，所以会报错！！！
	std::cout << "根据A文件夹中的【炒饭】菜谱，开始炒饭操作" << std::endl;
	fa();
    return 0;
}

以下是输出结果(可以看到报错了，因为找不到菜谱了)：

根据B文件夹中的【炒饭】菜谱，开始炒饭操作
炒饭中...
根据A文件夹中的【炒饭】菜谱，开始炒饭操作
terminate called after throwing an instance of 'std::bad_function_call'
  what():  bad_function_call
Aborted

所以我们可以得出结论：

1.swap方法可以做交换操作。

2.swap方法可以做转移操作。

3.swap方法转移后，不可以再调用原有函数。

---

0.3 将函数作为参数传递

这里只需要对上面的方法进行改造就行：

#include <iostream>
#include <functional>

void print(){
    std::cout << "Hello I am XYZ" << std::endl;
}

void func(std::function<void()> cb){
    std::cout << "函数传入后的地址:" << &cb << std::endl;
    std::cout << "传入函数后调用" << std::endl;
    cb();
}


int main(int argc, char** argv){
    std::function<void()> f = print;
    std::cout << "函数传入前的地址:" << &f << std::endl;
    func(f);
    std::cout << "回调完成后再次调用" << std::endl;
    f();
    return 0;
}

可以看到以下输出：

函数传入前的地址:0x7ffd12c6adb0
函数传入后的地址:0x7ffd12c6aaa0
传入函数后调用
Hello I am XYZ
回调完成后再次调用
Hello I am XYZ

可以看到调用非常成功！但是传入前后地址不一样，证明是值传递 ，会有复制 的操作，不是很理想。

所以我们将值传递改为引用传递，避免不必要的拷贝操作。

---

0.4 将函数的引用作为参数传递

#include <iostream>
#include <functional>

void print(){
    std::cout << "Hello I am XYZ" << std::endl;
}

//！！！只要改动此处入参类型就行 加了& ！！！
void func(std::function<void()>& cb){
    std::cout << "函数传入后的地址:" << &cb << std::endl;
    std::cout << "传入函数后调用" << std::endl;
    cb();
}


int main(int argc, char** argv){
    std::function<void()> f = print;
    std::cout << "函数传入前的地址:" << &f << std::endl;
    func(f);
    std::cout << "回调完成后再次调用" << std::endl;
    f();
    return 0;
}

可以看到以下输出中，地址是同一个(避免了不必要的拷贝操作)：

函数传入前的地址:0x7ffee22f8170
函数传入后的地址:0x7ffee22f8170
传入函数后调用
Hello I am XYZ
回调完成后再次调用
Hello I am XYZ

以上看似比较完美的方式，仔细想想可能还有问题。

有一些情况下，我们作为入参的函数被传入后希望不再其他地方被使用，

或者这个函数除了作为入参在内部调用之外没有其他地方被调用。

那么我们希望再该函数作为入参调用后将对其的引用解除掉。

翻译成人话就是：有个方法fun1使用引用传递的方式，作为入参传递到fun2内部，

在fun2内部调用传入的fun1后，将fun1方法置空。

所以我们看到**【置空】就能想到上面的使用swap进行 【转移】**。

代码如下：

#include <iostream>
#include <functional>

void print(){
    std::cout << "Hello I am XYZ" << std::endl;
}

void func(std::function<void()>& cb){
    std::cout << "函数传入后的地址:" << &cb << std::endl;
    std::cout << "传入函数后调用" << std::endl;
    //这里用局部变量来接收，这样超出作用域后会自动销毁
    std::function<void()> call_back;
    //!!!此处进行了转移操作!!!
    call_back.swap(cb);
    call_back();
}

int main(int argc, char** argv){
    std::function<void()> f = print;
    std::cout << "函数传入前的地址:" << &f << std::endl;
    func(f);
    std::cout << "回调完成后再次调用" << std::endl;
    //！！！这里再次调用一定会出错！！！
    f();
    return 0;
}

可以看到输出如下：

函数传入前的地址:0x7ffc81e0dcb0
函数传入后的地址:0x7ffc81e0dcb0
传入函数后调用
Hello I am XYZ
回调完成后再次调用
terminate called after throwing an instance of 'std::bad_function_call'
  what():  bad_function_call
Aborted

可以看到上面最后的报错！这正是我们想要的结果！

通过报错提示我们不要在回调函数外部再次调用这个方法。

这个方式其实可以有效避免一些智能指针 引用计数问题，具体的会在之后篇章里介绍 【记得关注我】

---

实在太累了，连续熬夜好几天了，今天先到这吧，明天我来继续补充。

关注我的小伙伴可以明天晚上再来这里看后续哈。

今天是【2024-04-25 23:05】

后面部分可以明天再来看哦，因为我还没刷完这部分视频

我先不写了，继续刷sylar视频去了。。。

未完待续...

---

1. 使用pthread库

在正式学习Sylar线程模块之前我们先熟悉以下C++11的pthread库的基本使用。

不知道在做的各位是否有遇到问题，总之我是一步一磕绊 。

我是拉取Sylar项目后学多少就切到对应分支查看对应代码的，所以会遇到这个问题。

我查看了Sylar项目的CMakeLists.txt，应该是有问题的，这里给个截图给大家避坑了（对应版本：git reset --hard 846054e）：

以下是我修改后的CMakeLists.txt，因为我在这一章只学线程相关的，所以删除了一些不必要的东西：

cmake_minimum_required(VERSION 2.8)
project(sylar)

include (cmake/utils.cmake)

set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} -rdynamic -O0 -ggdb -std=c++11 -Wall -Wno-deprecated -Werror -Wno-unused-function -Wno-builtin-macro-redefined")

include_directories(.)
include_directories(/apps/sylar/include)
link_directories(/apps/sylar/lib)

set(
	LIB_SRC
    sylar/log.cc
    sylar/util.cc
    sylar/config.cc
	)

add_library(sylar SHARED ${LIB_SRC})
force_redefine_file_macro_for_sources(sylar) #__FILE__

find_library(PTHREAD pthread)

set(
	LIBS
    sylar
    ${PTHREAD }
	)

add_executable(test_thread tests/test_thread.cc)
add_dependencies(test_thread sylar)
force_redefine_file_macro_for_sources(test_thread) #__FILE__
target_link_libraries(test_thread ${LIBS})

SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
SET(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)

我们先在test_thread.cc中编写以下代码，

这里我用截图是为了让大家自己敲一边，因为我自己写的时候才会遇到各种问题，

我自己出错和担心大家出错的地方做了标注：

如果你敲了以上的代码并且能输出以下信息：

====thread====
Hello thread 139660689327872
====end====

那么恭喜你，你已经会最基本的C++ pthread库的使用了！