1.1注释

1.1.1 注释行

Cmake使用#进行行注释，可以放在任何位置

1
2

#这是一个CMake行注释
cmake_minimum_required(VERSION 4.0.0)

1.1.2注释块

Cmake使用#[[]]进行块注释

1
2
3
4

#[[注释第一行
注释第二行
注释第三行]]
cmake_minimum_required(VERSION 4.0.0)

1.2 CMake两种基本用法

1.2.1 所有文件共处一个目录下

3. 添加CMakeLists.txt文件：

1
2
3

cmake_minimum_required(VERSION 3.5.0)
project(Test)
add_executable(Test main.cpp)

• cmake_minimum_required（可选）：指定使用的最低版本，如果不写可能会有警告
• project：定义工程名称，并且可以指定工程的版本、工程描述、web主页地址、支持的语言，其中工程名称是必填项，其余的为选填

1
2
3
4
5
6
7

#project命令格式
project(<Project_name> [<language_name>])
project(<project_name>
[VSERSION <major>[.<minor>[.<patch>[.<tweak>]]]]
[DESCRIPTION] <project-description-string>
[HOMEPAGE_URL <url-string>]
[LANGUAGES] <language-name>...)

• add_executable:定义工程生成一个可执行程序

1

add_executable(可执行程序名称 源文件名称...)

这里的可执行程序名称只是最后生成的exe文件名称，与项目名称是两码事，源文件名可以有多个，多个使用空格或者分号来处理

1. 执行CMake命令：

在执行cmake命令时要确保执行命令所在的路径在项目根目录中即CMakeLists.txt所在目录中

1
2
3
4
5
6
7
8
9
10
11

#执行以下指令进行生成对应文件
cmake <CMakeLists所在目录>#生成文件的目的目录就是执行指令所在目录

#在windows下如果没有生成Makefile文件那么需要写
cmake <CMakeLists所在目录> -G "Unix Makefiles"

#在MinGW下要写
cmake <CMakeLists所在目录> -G "MinGW Makefiles"

#执行完毕后再执行以下指令生成对应文件
make

1.3基本配置

1.3.1变量

在CMake中很多时候我们也可以使用变脸来管理一些参数，比如上文中的add_executable中如果有多个文件那么就需要使用变量来管理

• 设置变量 set

具体语法如下：

1
2
3

#set语法
#[]中的参数为可选项，不需要可以不写
set(var [VALUE] [CACHE TYPE DOCSTRING [FORCE]])

• var:变量名
• VALUE：变量值，一个变量可以存储多个值且所有的值都属于字符串形式存储，当有多个时打印出来的会显示为一整行，在存储时会用分号隔开

1
2
3
4

#set设置变量
set(src_list main.cpp add.cpp)
#在引用时需要使用${}
add_executable(app ${src_list})

1.3.2确立语言标准

在编写c++时，可能会用到c++11、c++14、c++17、c++20等版本指定，那么就需要在编译时指定要使用那个版本去编译cpp程序

1

g++ *.cpp -std=c++11 -o app

在上述例子中通过参数-std=c++11我们指定了需要使用c++11来编译文件，c++标准对应有个宏叫DCMAKE_CXX_STANDARD。在CMake中规定cpp有两种方式：

1. 使用CMakeLists直接规定：

1
2
3
4
5
6
7
8

#使用c++11标准
set(CMAKE_CXX_STANDARD 11)
#使用c++14标准
set(CMAKE_CXX_STANDARD 14)
#使用c++17标准
set(CMAKE_CXX_STANDARD 17)
#使用c++20标准
set(CMAKE_CXX_STANDARD 20)

1. 在执行cmake时就指定了标准：

1
2
3
4
5
6
7
8

#使用c++11标准
cmake <CMakeLists.txt文件路径> -DCMAKE_CXX_STANDARD=11
#使用c++14标准
cmake <CMakeLists.txt文件路径> -DCMAKE_CXX_STANDARD=14
#使用c++17标准
cmake <CMakeLists.txt文件路径> -DCMAKE_CXX_STANDARD=17
#使用c++20标准
cmake <CMakeLists.txt文件路径> -DCMAKE_CXX_STANDARD=20

1.3.3指定输出路径

在CMake中输出路径也是由一个宏来存储的叫做EXECUTABLE_OUTPUT_PATH，它的值通过set进行设置

1
2

#假定设置好了set(HOME <项目目录>)
set(EXECUTABLE_OUTPUT_PATH ${HOME}/bin)

这里的演示是绝对路径，但是在具体项目中建议使用相对路径。

以及如果EXECUTABLE_OUTPUT_PATH对应目录不存在CMake会自动帮我们创建

1.4搜索文件

在上文中我们使用了变量来管理文件，但是当我们项目文件数很多时，使用变量去记录罗列同样也很麻烦，所以我们需要使用cmake中给我们提供的文件搜索功能来统一管理

方式1：使用aux_source_directory

1

aux_source_directory(<dir> <virable>)

• dir：要搜索的目录
• virable：将从dir目录下搜索到的文件存储到这个变量中

使用示例：

1
2
3
4
5
6

cmake_minimum_required(VERSION 3.3.0)
project(Test)
include_directories(${PROJECT_SOURCE_DIR}/include)
#搜索源文件
aux_source_directory(${PROJECT_SOURCE_DIR/src SRC_LIST})
add_executable(app SRC_LIST)

• PROJECT_SOURCE_DIR这个宏是用户在输入时的路径，如果用户不输入就是默认执行CMakeLists所在的路径，大多是根目录下的顶层CMakeLists.txt所在目录

方式2：使用file

在一个项目里源文件很多可以使用file来搜索（但是其功能不局限于搜索）

1

file(GLOB/GLOB_RECURSE 变量名 要搜索的文件类型)

• GLOB：将指定目录下的搜到的满足条件的文件名生成一个列表来存储
• GLOB_RECURSE：递归搜索指定目录，将搜索道德满足条件的文件名生成一个列表来存储

使用示例：

1
2

file(GLOB MAIN_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
file(GLOB MAIN_HEAD ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h)

• CMAKE_CURRENT_SOURCE_DIR：这个宏表示当前访问的CMakeLists文件所在路径
• 其中路径参数可以加双引号也可以不加

1.5包含头文件

在项目编译源文件时，很多时候需要将源文件对应头文件路径指定出来，这样才能保证编译过程中编译器能够找到这些头文件，顺利通过编译。在CMake中引入头文件使用include_directories:

1

include_directories(<headpath>)

使用示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

├── CMakeLists.txt
├── include
│   ├── add.h
│   ├── div.h
│   ├── mult.h
│   └── sub.h
├── main.cpp
└── src
    ├── add.cpp
    ├── div.cpp
    ├── mult.cpp
    └── sub.cpp

2 directories, 10 files

1.6库制作

有些时候我们并不需要将他们编译为可执行程序，而是生成一些动态/静态库分享给第三方使用。

如果要制作静态/动态库，需要使用的命令如下：

1
2

add_library(库名称 STATIC 源文件1 [源文件2]...)#静态库
add_library(库名称 SHARED 源文件1 [源文件2]...)#动态库

在linux中，静态库分为三个部分：lib+库名字+.a,在生成之后会自动填充剩余部分，我们只需要指定名字即可，在windows下同样只需要给出名字即可，如果是动态库则是.os结尾windows下则是.dll

同样使用以下目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

├── CMakeLists.txt
├── include
│   ├── add.h
│   ├── div.h
│   ├── mult.h
│   └── sub.h
├── main.cpp
└── src
    ├── add.cpp
    ├── div.cpp
    ├── mult.cpp
    └── sub.cpp

2 directories, 10 files

这次我们只需要库泽CMakeLists内容如下：

1
2
3
4
5
6
7
8
9
10
11

cmake_minimum_required(VERSION 3.10.0)
project(Test CXX)

aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src src_list)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

# 制作库时不需要exe文件所以不需要此方法
# add_executable(Test main.cpp ${src_list})
add_library(Test STATIC ${src_list})
#动态库
#add_library(Test SHARED ${src_list})

• 如果要指定生成库的路径则需要改变LIBRARY_OUTPUT_PATH（对于静态库和动态库都适用）
• 指定生成可执行的文件路径使用EXECUTABLE_OUTPUT_PATH,（动态库也属于可执行文件但是静态库不属于，所以无法使用于静态库）

使用方式：

1
2

set(LIBRARY_OUTPUT_PATH ..)
set(EXECUTABLE_OUTPUT_PATH ..)

• 在分享给别人使用时需要给出库文件和头文件，只需要这两者即可

1.7库链接

再使用第三方库时cmake也为我们提供了链接第三方库的方法，在cmake中链接静态/动态库使用：

1

link_libraries(<lib/libname> [<static lib>]...)#（不推荐）

• 参数：想要链接的静态库的名字，可以写完整名字如libText.a也可以写掐头去尾的名字如Text

上方的link_libraries不推荐使用,因为其使用时是相当于全局载入会污染全局，在新版cmake中推荐使用target_link_libraries

1

target_link_libraries(<target> [PUBLIC/PRIVATE/INTERFACE] <lib/lib_name>)

• target：指定链接的对象
  • 这个对象可能是源文件
  • 这个对象可能是动态库文件
  • 这个对象可能是一个可执行文件
• PUBLIC/PRIVATE/INTERFACE：指定动态库的访问权限，默认为PUBLIC
  • 如果各个库之间没有依赖关系，无需做任何设置，三者没有区别，一般无需指定，使用默认的PUBLIC即可
  • 动态库的链接具有传递性,如果之前有动态库A、B、C链接，然后又有动态库D链接了动态库A则相当于D也连接了B和C（注意，只有在PUBLIC模式下才有传递性中间有任何一个使用了PRIVATE的话则对应库无法被传递出去）
  • 三个选择的区别：
    • PUBLIC：此模式下对应链接的库会被连接到target中，并且符号也会被导出
    • PRIVATE：此模式下对应的库仅仅被链接到target中，并且终止，第三方无法感知你调用了什么库
    • INTERFACE：这个模式下对应的库不会被链接到target中，只会导出符号
• lib/lib_name：指定链接的库
• 注意：参数2和3一般是一个整体的参数，可以有多个，并且使用target_link_libraries时应该在add_executable之后

如果该库不是系统提供的（自己制作或者第三方提供的）可能出现库找不到的现象，此时可以将库的路径也指定出来。使用（也同样适用动态库）：

1

link_directories(<lib_path> [<lib_path>])#这里可以指定多个路径

项目结构为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

.
├── CMakeLists.txt
├── a
│   └── libTest.a
├── compile_commands.json -> build/compile_commands.json
├── include
│   ├── add.h
│   ├── div.h
│   ├── mult.h
│   └── sub.h
├── main.cpp
├── so
│   └── libTest.so
└── src
    ├── add.cpp
    ├── div.cpp
    ├── mult.cpp
    └── sub.cpp

这样我们的CMakeLists代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13

cmake_minimum_required(VERSION 3.10.0)
project(Test CXX)

# aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src src_list)
#此时不需要其他的cpp文件只需要main文件即可
set(src_list ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp)
#指定头文件
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
#设置库位置
link_directories(${CMAKE_CURRENT_SOURCE_DIR}/a)
#链接静态库
link_libraries(Test)
add_executable(app ${src_list})

1.8日志

在CMake中提供了显示指令message：

1

message([STATUS/WARNING/AUTHOR_WARNING/SEND_ERROR/FATAL_ERROR] "message info")

• （无）：重要消息
• STATUS：非重要消息
• WARNING：CMake警告，但是会继续执行
• AUTHOR_WARNING：CMake警告(dev),会继续执行
• SEND_ERROR：CMake错误，继续执行，但是会跳过生成步骤
• FATAL_ERROR：CMake错误，终止所有处理过程

使用示例

1
2
3
4
5
6

#输出一般信息
message(STATUS "project_path:${CMAKE_CURRENT_SOURCE_DIR}")
#输出警告信息
message(WARNING "project_path:${CMAKE_CURRENT_SOURCE_DIR}")
#输出严重错误信息
message(FATAL_ERROR "project_path:${CMAKE_CURRENT_SOURCE_DIR}")

1.9变量操作

1.9.1字符串的追加

有时候在项目中源文件并不一定都在同一个文件夹中，但是文件最终需要一起来编译最终可执行文件或者库文件，使用file 对各个路径进行搜索后还需要一个字符串拼接操作，字符串拼接操作可以用set进行也可以使用list进行

• 使用set

1

set(变量名 ${变量名1} ${变量名2} ...)

上述方式是从变量名1开始依次向后拼接，最后放到一个新的变量中去如果这个新的变量名有数据那么就会被覆盖掉

• 使用list：

1

list(APPEND <list> [<element> ...])

list的功能比set强大，字符串拼接只是其中一功能，他需要在第一个位置指定出我们要做的操作，APPEND表示数据追加，后面的参数就和set一样了。

注意：在cmake底层管理时这些字符串是通过;来分隔管理的，但是一般输出时看的是一个完整的字符串

1.9.2字符串的移除

在通过file搜索某个目录时，就得到了该目录下所有的文件，但是有时候我们需要排除其部分文件则需要使用字符串移除的操作还是使用list

1

list(REMOVE_ITEM <list> [<element> ...])

与上面的追加一样的格式，但是是将第一个参数改为了REMOVE_ITEM

注意：由于搜索文件后实际上是存储的对应文件的完整路径，那么在剔除某个特定文件时实际上应该是剔除这个完整路径元素

1.9.3list的其余操作

1. 获取list长度

1

list(LENGTH <list> <output_virable>)

• LENGTH：命令参数，用于获取读列表长度
• <list>：当前操作的列表
• <output_variable>：新创建的变量用来存储结果

1. 读取列表中指定索引的元素，可以指定多个索引

1

list(GET <list> <element index> [<element index> ...] <output_variable>)

• <list>
• <element index>：列表元素的索引
  • 从0开始编号，索引0的元素是列表第一个元素
  • 索引也可以是负数，例如-1表示最后一个数，-2表示倒数第二个数
  • 当索引长度超过列表长度就会报错（不论正负）
• <output variable>：创建新变量存储结果

1. 将列表中元素用连接符（字符串）连接起来组成一个字符串

1

list(JOIN <list> <value> <output variable>)

• <list>：当前操作列表
• <value>：指定字符串
• <output variable>：创建新变量存储结果

1. 查找列表是否存在指定元素，若未找到，返回-1

1

list(FIND <list> <value> <output variable>)

• <list>：当前操作列表
• <value>：指定需要查询的内容
• <output variable>：创建新变量存储结果
  • 如果<list>中存在<value>就返回下标，否则就返回-1

1. 将元素追加到列表中

1

list(APPEND <list> [<element> ...] <output>)

1. 在指定位置插入若干个元素

1

list(INSERT <list> [<element> ...] <output>)

1. 将元素插入到列表0索引位置

1

list(PREPEND <list> [<element> ...])

1. 将列表中最后一个元素移除

1

list(POP_BACK <list> [<out_var> ...])

1. 将列表第一个元素移除

1

list(POP_FRONT <list> [<out_var> ...])#如果指定了变量就会存入变量，否则不存储

1. 将指定元素从列表中移除

1

list(REMOVE_ITEM <list> <value> [<value> ...])#如果指定了变量就会存入变量，否则不存储

1. 将指定索引位置元素从列表中移除

1

list(REMOVE_AT <list> <index> [<index> ...])#如果指定了变量就会存入变量，否则不存储

1. 移除列表中重复元素

1

list(REMOVE_DUPLICATES <list>)

1. 列表翻转

1

list(REVERSE <list>)

1. 列表排序

1

list(SORT <list> [COMPARE <compare>] [CASE <case>] [ORDER <order>])

• COMPARE：指定排序方法

  • STRING：按照字母顺序进行排序（为默认排序方法）
  • FILE_BASENAME：如果是一系列路径名，会使用basename进行排名
  • NATURAL：使用自然数排序

• CASE：指明是否大小写敏感

  • SENSITIVE：按照大小写敏感的方法进行排序（为默认方法）
  • INSENSITIVE：按照大小写不敏感的方法进行排序
• ORDER：指明排序顺序
  • ASCENDING：按照升序排列（为默认方法）
  • DESCENDING：按照降序排列

1.10宏定义

在进行代码编写时我们有时候需要一个宏变量来控制程序，如：

test.cpp:

1
2
3
4
5
6
7
8
9

#include <iostream>

int main(){
    int a =10;
#ifdef DEBUG
std::cout << "这是DEBUG模式" << std::endl;
#endif
    std::cout << "程序运行完成" << std::endl;
}

在程序第五行中，如果这个宏被定义了则就会输出这个消息，如果没定义就不会输出，在代码中我们明显看到没有定义，实际运行时就不会出现输出

为了让测试更灵活我们可以不在代码中明确定义，在测试时去定义，一种方式就是在gcc/g++运行时去定义 如下：

1

gcc test.cpp -DDEBUG -o app

在gcc/g++命令中我们通过使用-D参数来定义宏名字.

在cmake中我们也可以做类似的事情，对应的命令叫：add_definitions：

1

add_definitions(-D宏名称)

具体：

1

add_definitions(-DDEBUG)

2. CMake嵌套

如果项目很大，或者项目中有很多源码目录，在通过CMake管理项目的时候如果只使用一个CMakeLists.txt，那么这个文件相对会比较复杂，有一种化繁为简的方式就是给每一层目录都加一个CMakeLists.txt文件（头文件目录不需要），这样每个文件都不会太复杂，而且更灵活，更容易维护。

如果想使用子节点的CMakeLists.txt则需要将子节点加入到父节点的CMakeLists.txt中，CMake为我们提供了add_subdirectory

注意：父节点中的CMakeLists中的变量可以为子节点所用，但是子节点的不可为父节点所用

1

add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

• source_dir：指定了CMakeLists.txt和源代码的位置，就是指定子目录
• binary_dir：指定了输出文件的路径，一般不需要指定，忽略即可
• EXCLUDE_FROM_ALL：在子目录下的目标默认不会被包含到父路径的ALL目标里，并且也会被安排在IDE工程文件之外。用户必须显式构建在子路径下的目标，基本不用

使用演示

项目目录如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

.
├── CMakeLists.txt
├── include
│   ├── add.h
│   ├── div.h
│   ├── mult.h
│   └── sub.h
├── src
│   ├── CMakeLists.txt
│   ├── add.cpp
│   ├── div.cpp
│   ├── mult.cpp
│   └── sub.cpp
└── test
    ├── CMakeLists.txt
    └── main.cpp

根目录下CMakeLists.txt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

cmake_minimum_required(VERSION 3.10.0)
project(Test CXX)

# 定义变量
# 静态库生成路径
set(LIBPATH ${PROJECT_SOURCE_DIR}/lib)

# 可执行程序存储目录
set(EXEPATH ${PROJECT_SOURCE_DIR}/bin)

# 头文件路径
set(HEADPATH ${PROJECT_SOURCE_DIR}/include)

# 库文件名字
set(TESTLIB Test)
set(SRCLIB Src)

# 可执行程序名字
set(APPNAME app)

# 添加子目录
add_subdirectory(src)
add_subdirectory(test)

src/CMakeLists.txt

1
2
3
4
5
6
7
8
9
10

# 搜索源文件
aux_source_directory(./ SRC)

# 指定头文件的位置
include_directories(${HEADPATH})

# 指定静态库的生成
set(LIBRARY_OUTPUT_PATH ${LIBPATH})

add_library(${SRCLIB} STATIC ${SRC})

test/CmakeLists.txt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 搜索源文件
aux_source_directory(./ SRC)

# 指定头文件的位置
include_directories(${HEADPATH})

set(EXECUTABLE_OUTPUT_PATH ${EXEPATH})

# 生成可执行文件
add_executable(${APPNAME} ${SRC})

# 指定链接库位置
link_directories(${LIBPATH})

# 链接库
target_link_libraries(${APPNAME} ${SRCLIB})

3. CMake语法

3.1 流程控制if、loop

3.1.1判断语句

• if语法：

if(\)

\

elseif(\)

\

else()

\

endif()

用法演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

set(varbool TRUE)

if(varbool)
    message(TRUE)
else()
    message(FALSE)
endif()

if(NOT varbool OR varbool)
    message(TRUE)
else()
    message(FALSE)
endif()

if(NOT varbool AND varbool)
    message(TRUE)
else()
    message(FALSE)
endif()

if(1 LESS 2)
    message("1 LESS 2")
endif()

if("ok" LESS 233)
    message("ok LESS")
endif()

if("2" EQUAL 2)
    message("EQUAL")
endif()

3.1.2 循环语句

• for语法:

foreach(\ RANGE \)

​ \

enfforeach()

foreach(\ RANGE \ \ [\])

foreach(\ IN [LISTS \] [ITEMS \])

foreach(\ IN ZIP_LISTS \ \…)

使用ZIPLISTS时取用时${num\}

• while语法：

while(\)

\

endwhile()

使用演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

cmake_minimum_required(VERSION 4.00.0)

foreach(var RANGE 3)
    message(${var})
endforeach()

set(my_list 1 2 3)

foreach(var IN LISTS my_list ITEMS 4 f)
    message(${var})
endforeach()

#zip
set(L1 one two three four)
set(L2 1 2 3 4)

foreach(num IN ZIP_LISTS L1 L2)
    message(word = ${num_0},num = ${num_1})
endforeach()

运行结果如下：

1
2
3
4
5
6
7
8

2
3
4
f
word=one,num=1
word=two,num=2
word=three,num=3
word=four,num=4

3.2 函数

语法:

function(\ [\…])

\

endfunction()

使用示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

cmake_minimum_required(VERSION 4.00.0)

function(MyFunc firstArg)
    message("my func name: ${CMAKE_CURRENT_FUNCTION}")
    message("FirstArg ${firstArg}")

    set(firstArg "New value")
    message("New firstArg:${firstArg}")

    message("ARGV0:${ARGV0}")
    message("ARGV1:${ARGV1}")
    message("ARGV2:${ARGV2}")
endfunction()

set(var "first value")
MyFunc(${var} "value")

运行后得到：

1
2
3
4
5
6

my func name: MyFunc
FirstArg first value
New firstArg:New value
ARGV0:first value
ARGV1:value
ARGV2:

实际上虽然我们确定了是一个参数，但是依旧可以传递多个参数，在这里函数依旧可以捕捉到多余的参数。

3.3 cmake作用域

cmake有两个作用域;

• function scope函数作用域
• Directory scope 当从add_subdirectory()命令执行嵌套目录中的CMakeLists.txt列表文件时，注意父CMakeLists.txt其中的变量可以被子CMakeLists.txt使用

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

cmake_minimum_required(VERSION 4.00.0)
project(scope)

function(OutFunc var)
    message("----------enter OutFunc----------")
    set(var 2)
    message("var: ${var}")
    InFunc(${var})
    message("var: ${var}")
endfunction()

function(InFunc var)
    message("----------enter InFunc----------")
    message("var: ${var}")
    set(var 3)
    message("var: ${var}")
endfunction()

set(var1 1)
message(${var1})
OutFunc(${var1})
message(${var1})

运行：

1
2
3
4
5
6
7
8
9
10
11
12
13

cmake -B build
运行结果
1
----------enter OutFunc----------
var: 2
----------enter InFunc----------
var: 2
var: 3
var: 2
1
-- Configuring done (0.0s)
-- Generating done (0.0s)
-- Build files have been written to: /home/ghl/project/cmake_learn/cmakefiles/scope/build

3.4 宏

语法

macro(\ [\…])

\

endmacro()

注意：尽量不要写宏，会读就行

1
2
3
4
5
6
7
8
9
10
11

cmake_minimum_required(VERSION 4.00.0)

macro(my_macro var)
    set(var "new value") # 创建了一个新的var变量
    message("argment: ${var}")
endmacro()

set(var "first value")
message("var:${var}")
my_macro("value")
message("var:${var}")

运行结果：

1
2
3

var:first value
argment: value
var:new value

注意，当使用了宏以后内部赋值会改动外部同名变量的内容，起传入的参数在内部使用，宏生效后同名外部变量会被改变

阻塞&非阻塞IO

基本概念：

• 阻塞：在进/线程中，发起一个调用时，在调用返回前，进/线程会被阻塞等待，等待中进/线程让出cpu的使用权。
• 非阻塞：在进/线程中，发起一个调用时，会立刻返回。
• 会阻塞的四个函数：connect()、accept()、send()、recv()。

应用场景：

• 传统的网络服务端中（每连接每线程/进程），采用阻塞IO。
• 在IO复用模型中，事件循环不能被阻塞在任何环节，所以应该采用非阻塞IO。

非阻塞IO-connect()

• 对非阻塞的IO调用connect()函数会返回失败，errno ==EINPROGRESS。
• 对非阻塞的IO调用connect()函数后，如果socket的状态是可写的，证明连接是成功的，否则是失败的。

设置socket为非阻塞：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <fcntl.h>

int setnonblocking(int fd){
    int flags;
    
    //获取fd状态
    if((flags = fcntl(fd,F_GETFL,0))==-1)
        flags = 0;
    return fcntl(fd,F_SETFL,flags|O_NONBLOCK);
}

//在客户端中创建了socket后设置为非阻塞

int sockfd
if((sockfd =socket(AF_INET,SOCK_STREAM,0))<0){printf("socket()failed\n");return -1;}

setnonblocking(sockfd);

非阻塞IO-accept()

• 对非阻塞的IO调用accept()，如果已连接队列中没有socket,函数立即返回失败，errno == EAGAIN

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <fcntl.h>

int setnonblocking(int fd){
    int flags;
    
    //获取fd状态
    if((flags = fcntl(fd,F_GETFL,0))==-1)
        flags = 0;
    return fcntl(fd,F_SETFL,flags|O_NONBLOCK);
}

//在客户端中创建了socket后设置为非阻塞

int listenfd = initserver(IP)

setnonblocking(listenfd);
//对于非阻塞的accept返回失败要判断错误代码
if(accept(listensock,0,0)==-1){
    if(errno != EAGAIN){
        perror("accept()");
        return -1;
    }
    
}

非阻塞IO-recv和send

• 对于非阻塞的IO调用recv()如果没有数据可以读（接收缓存区为空），函数立即返回失败，errno==EAGAIN

• 对于非阻塞IO调用send()，如果socket不可写（发送缓冲区已满），函数立即返回失败，errno==EAGAIN

水平触发&边缘触发

水平触发

• 读事件：如果epoll_wait触发了读事件，表示数据可读，如果程序没有把数据读完，再次调用了epoll_wait,将立即再次触发读事件
• 写事件：如果发送的缓冲区没有满，表示可以写入数据，只要缓冲区没有被写满，再次调用epoll_wait的时候将立即再次触发写事件。

边缘触发

• 读事件：epoll_wait触发读事件后，不管程序有没有处理读事件，epoll_wait都不会再触发读时间，只有当新数据到达时，才再次触发读事件。
• 写事件：epoll_wait触发写事件之后，如果缓冲区仍可以写（发送缓冲区没有满），epoll_wait不会再次触发写事件，只有当发送缓存区由满变成不满时，才再次触发写事件。

1
2
3
4
5
6
7
8

//默认情况下epoll是水平触即设置事件时只需要设置为EPOLLIN/EPOLLOUT即可进行水平触发
epollevent ev;
ev.data.fd = listensock;
ev.events = EPOLLIN;

//若进行边缘触发则
ev.events = EPOLLIN|EPOLLET;//即可切换为边缘触发

示例代码：

在网络编程（四）中我们这里的使用如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 if(evs[ii].data.fd == listensock){
   struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
   
   printf("accept client(socket = %d)ok.\n",clientsock);

   ev.data.fd =clientsock;
   ev.events = EPOLLIN;
   epoll_ctl(epollfd,EPOLL_CTL_ADD,clientsock,&ev);
}else{

   char buffer[1024];
       memset(buffer,0,sizeof(buffer));
       if(recv(evs[ii].data.fd,buffer,sizeof(buffer),0)<=0)
       {
           printf("client(eventfd = %d) disconnected.\n",evs[ii].data.fd);
           close(evs[ii].data.fd); 
       }else{
           printf("recv(eventfd = %d):%S\n",evs[ii].data.fd，buffer);
           send(evs[i].data.fd，buffer,strlen(buffer),0);
       }
}

以上代码是我们在前置条件为水平触发时对连接处理的 代码，那么切换至边缘触发后以上的多个客户端的连接处理过程中会造成连接丢失的情况所以需要使用循环，那么如果要使用循环就需要将accept使用非阻塞的模式，以防止阻塞循环的进行,同理recv

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

int setnonblocking(int fd){
    int flags;
    
    if((flags = fcntl(fd,F_GETFL,0))==-1)
        flags = 0;
    
    return fcntl(fd,F_SETFL,flags|O_NONBLOCK);
}

int main(){
    ...
    setnonblocking(listensock);//将监听设置为非阻塞
...
    epoll_event ev;
    ev.data.fd = listensock;
    ev.events = EPOLLIN|EPOLLET

if(evs[ii].data.fd == listensock){
    while(true){  
       struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        
            if((clientsock<0)&&(errno == EAGAIN)) break;//此时才是真正的没有了连接可以退出循环
            
        printf("accept client(socket = %d)ok.\n",clientsock);

        ev.data.fd =clientsock;
        ev.events = EPOLLIN;
        epoll_ctl(epollfd,EPOLL_CTL_ADD,clientsock,&ev);
        }
    }else{
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));
        int readn;//每次调用recv的返回值
        char* ptr = buffer;//buffer指针的位置
        while(true){
            if(recv(evs[ii].data.fd,buffer,sizeof(buffer),0)<=0)
            {
                if((readn<=0)&& (errno== EAGAIN))
printf("recv(eventfd = %d):%S\n",evs[ii].data.fd，buffer);
                send(evs[i].data.fd，buffer,strlen(buffer),0);
            }else{//其他情况均是连接丢失
                printf("client(eventfd = %d) disconnected.\n",evs[ii].data.fd);
                close(evs[ii].data.fd); 
                break;
            }else{
                ptr = ptr+readn;//buffer的报文结尾位置后移
            }
        }
        
    
}
}

注意：以上代码中，边缘触发的代码再水平触发模式可以使用，但是水平出发的代码场景无法给边缘触发使用。

IO多路复用模型

IO多路复用就是用一个线程/进程处理多个TCP以减少系统开销。

IO多路复用模型有三种：select(1024)，poll(数千)，epoll(百万)。

重点概念：

• 网络通讯的读事件：

  1. 已连接的队列中已经有准备好的socket(有新的客户端连接上来)
  2. 接收缓存中有数据可以读（对端发送的报文已到达）
  3. tcp连接已断开（对端调用close()函数关闭了连接）

• 网络通讯的写事件：

  发送缓冲区没有满，可以写入数据（可以向对端发送报文）

1. select模型

1
2

//select模型需要调用select函数
int select(int fds,fd_set *readfds, fd_set *writefds,fd_set* exceptfds,struct timeval*timeout);

select():允许程序同时监视多个文件描述符，检测他们的变化（如数据可读可写），从而高效的管理多个I/O操作，而不需要单独为每个操作创建独立的线程或进程，同时也支持非阻塞IO。

• fd_set:这个结构体是用来存储链接的集合，本质是一个32位的整形数组，所以共有$4832=1024$bitmap位

  其中提供了四个宏来操作位图：

  1. void FD_CLR(int fd,fd_set *set):将对应socket从位图中删除
  2. int FD_ISSET(int fd,fd_set *set):判断socket是否在位图中，如果不在返回0，如果在返回大于0的值
  3. void FD_SET(int fd,fd_set *set):将socket加入到对应位图中
  4. FD_ZERO(fd_set* set):初始化位图，将其中1024个位置都置为0

  1 2 3

  fd_set readfds; //需要监视的读事件的socket集合，大小为16字节（1024位）的bitmap FD_ZERO(&readfds); //初始化readfds FD_SET(listensock,&readfds);//把服务端监听的socket加入bitmap

• timeval:是超时时间的结构体：

  成员有：tv_sec和tv_usec分别是超时的秒和微秒

  1 2 3

  struct timeval timeout; timeout.tv_sec = 10;//秒 timeout.tv_usec = 0;//微秒

• fds:实际操作的bitmap的大小+1，告诉要操作的bitmap

• readfds：需要监视的读的bitmap

• writefds：需要监视的写的bitmap

• exceptfds：需要监视的异常的bitmap，select也可以监视普通IO,在监视普通IO时多用网络编程中不常用。

• timeout：超时时间阈值设置

  1. 如果为NULL，那么select会无限等待直到至少有一个文件描述符就绪
  2. 如果两个参数都设置为0，select会立即返回用于轮询
  3. 设置具体时间后，在这段时间内select会等待文件描述符就绪，时间结束会返回超时报错。

使用：

1
2
3
4

int maxfd = listensock;//获取readfds中实际的最大值
fd_set tmpfds = readfds;//因为在select中位图会被操作修改所以这里要复制一份再传入
int infds = select(maxfd+1,&tmpfds,NULL,NULL,&timeout);
//tmpfds即告诉需要监视的读的bitmap，这里会修改bitmap所以需要复制一份

select返回值：

• 如果是小于零则调用失败

• 如果是等于0则是超时

• 如果成功调用则是返回成功发生事件的个数

  具体使用：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

  for (int eventfd=0;eventfd<=maxfd;eventfd++){//循环遍历bitmap if(FD_ISSET(eventfd,&tmpfds)==0)continue;//如果当前位置为0则没任何事件 //如果是listen发生了事件则是说明有客户端连接上来了（已经有准备好的socket） if(eventfd == listensock){ struct sockaddr_in client; socklen_t len =sizof(client); int clientsock = accept(listensock,(struct sockaddr*)&client,&len); if(listensock < 0){ perror("accept() faild"); continue; } std::cout << "accept client(socket ="<< clientsock<<") ok"<<std::endl; FD_SET(clientsock,&readfds); //把新连接上来的客户端标志位设置为1 if(maxfd < clientsock) maxfd = clientsock;//更新maxfd }else{//如果是客户端连接上的socket有事件，表示接收缓存中有数据可以读，或者有客户端断开连接 char buffer[1024]; memset(buffer,0,sizeof(buffer)); if(recv(eventfd,buffer,sizeof(buffer),0)<=0){ std::cout << "client(eventfd = "<< eventfd<<")disconnected"<<std::endl; close(eventfd); FD_CLR(eventfd,&readfds); if(eventfd == maxfd) for(int ii =maxfd;ii>0;ii--) if(FD_ISSET(ii,&readfds)){ maxfd = ii; break; } }else{ //如果有报文发送过来 std::cout << "recv(eventfd="<< eventfd<<"):"<<buffer<<std::endl; send(eventfd,buffer,strlen(buffer),0);//暂时把报文发送回去 } } }

• select-写事件：
  • 如果tcp发送缓存区没有满，那么，socket连接是可写的。
  • 一般来说，发送缓冲区不容易被填满。
  • 如果发送数据量太大，或者网络带宽不够，发送缓冲区有填满的可能性。
  • 综上所述，一般业务中不需要关心监听写事件

• select-水平触发：

  • select()监视的socket如果发生了事件，select()会返回（通知应用程序处理事件）。
  • 如果事件没有被处理，再次调用select()的时候会立即再通知。

• select-压力测试：大概可以处理12w个事务

• select-存在的问题：
  • 采用轮询方式扫描bitmap，性能会随着socket数量增多而下降
  • 每次调用select()，需要拷贝bitmap
  • bitmap的大小（单个进程/线程打开的socket数量）由FD_SETSIZE宏设置，默认是1024个，可以修改，但是效率将更低。

2. poll模型

poll模型大体与select有些相似，再poll模型中要使用pollfd来存放需要监视的socket

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

pollfd fds[1024];

//pollfd结构体具体如下:
struct pollfd{
    int fd;//要监视的socket
    short events; //
    short revents; //当有事件发生时会修改此成员
}
//初始化使用以下方法：
for(int i = 0;i<1024;i++)
    fds[i].fd = -1;

//让poll监视事件
fds[listensock].fd = listensock;
fds[listensock].events = POLLIN;//读时间
/*fds[listensock].events = 
基本只用得到：
POLLIN   读事件
POLLOUT  写事件
   如果既需要读事件也需要写事件，可以如下使用;
   fds[listensock].events = POLLIN|POLLOUT;
*/

/*
    详解：
    events和revents共同可用：
    读事件：
    POLLIN     读普通或优先级数据
    POLLRDNORM 读普通数据
    POLLRDBAND 读优先级数据
    POLLPRI    读高优先级数据
    写事件
    POLLOUT    写普通数据
    POLLWRNORM 写普通数据
    POLLWRBAND 写优先级数据
    
    仅revents可用：
    异常：
    POLLERR     错误
    POLLHUP     挂起
    POLLNAV     文件描述符未打开
*/  

poll的具体使用

1

int poll(struct pollfd* nfds,nfds_t,int timeout);

• nfds：结构体数组地址
• nfds_t：结构体最大数+1
• timeout：超时时间（ms）

具体代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//初始化服务器监听端口获取listensock

pollfd fds[1024];

//初始化数组
for(int i=0;i <=1024;i++)
    fds[i].fd=-1;

//让poll监视listensock事件此处位置可以自由选择，也可以让监听事件顶格排布，也可以直接按数值位置排取决于自己
fds[listensock].fd = listensock;
fds[listensock].events = POLLIN;

int maxfds = listensock; //需要监视sock的实际大小

while(true){
    int infds = poll(fds,maxfd+1,10000);
    
    //如果infds < 0，表示调用失败
    if(infds < 0)
    {
        perror("poll()");
        break;
    }
    
    //如果infds = 0为超时
    if(infds == 0)
    {
        perror("poll(),timeout");
        break;
    }
    //大于0时是有事件发生
    for(int eventfd = 0;eventfd<=maxfd;eventfd++){
        if(fds[eventfd].fd < 0)continue;//忽略负fd
        if(fds[eventfd].events & POLLIN == 0)continue;//没有读事件，跳过
        if(eventfd == listensock){
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
            if(clientsock < 0){perror("accept() failed");continue;}
            
            printf("accept client(socket = %d)ok.\n",clientsock);
            
            //修改clientsock位置元素
            fds[clientsock].fd =clientsock;
            fds[clientsock].events = POLLIN;
            
            if(maxfd<clientsock) maxfd = clientsock;
        }else{
         
            char buffer[1024];
            memset(buffer,0,sizof(buffer));
            if(recv(eventfd,buffer,sizeof(buffer),0)<=0){
                //如果客户端连接已断开
                printf("client(eventfd= %d) disconnected.\n",eventfd);
              
                close(eventfd);
                fds[eventfd].fd=-1;
                //重新计算maxfd
                if(eventfd == maxfd)
                    for(int i=0;i>0;i--)
                        if(fds[i].fd!=-1)
                        {
                        maxfd = i;
                        break;
                        }
            }else{
                //如果有报文
                printf("recv(eventfd = %d):%s\n",eventfd,buffer);
                send(eventfd,buffer,strlen(buffer),0);
            }
        }
        
    }
    
}

• poll模型缺点：
  • 在程序中，poll的数据结构是数组，传入内核后转换成了链表
  • 每调用一次select()需要拷贝两次bitmap，poll拷贝一次结构体数组
  • poll监视没有1024的显示，但是同样是遍历的方式，所以依旧是监视的socket越多，效率越低

3. epoll模型

epoll模型解决了上面两个模型的痛点，再效率方面有了极大提升，根据以下介绍顺序逐步解释并且使用epoll

epoll的使用：

1

int epoll_create(); //创建epoll句柄

epoll_create()在linux2.6.8版本之前有一个int size的参数，在此之后就没有了被忽略掉了，填任意大于0的数即可

epoll的数据结构epoll_event:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

struct epoll_event{
    uint32_t events; //事件
    epoll_data_t data;//用户数据变量
};
/*
epoll的events与poll类似有：

EPOLLIN：可读事件。当接收缓冲区有数据可读时触发，例如套接字有新数据或管道写端关闭。
EPOLLOUT：可写事件。当发送缓冲区有空间可写时触发，适用于非阻塞连接完成或数据发送。
实际开发中以上两个常用，下列不常用

EPOLLERR：错误事件。文件描述符发生错误时自动触发。
EPOLLHUP：挂起事件。通常表示连接被对端关闭。
EPOLLRDHUP：对端关闭事件。用于检测 TCP 半关闭状态。
EPOLLPRI：紧急数据事件。适用于带外数据（如 TCP 紧急数据）。
EPOLLET：边缘触发模式，仅在状态变化时触发，适合高性能场景。
EPOLLONESHOT：单次触发模式，事件触发后需手动重新注册。
*/
/*用户数据变量的具体定义如下
typedef union epoll_data{
void  *ptr;
int   fd;
uint32_t u32;
uint64_t u64;
}epoll_data_t;
这里使用了哪种数据类型后续使用时就需要使用哪种
*/

epoll_event的使用:

1
2
3
4

//为服务端的listensock准备可读事件
epoll_event ev; //声明事件的数据结构
ev.data.fd = listensock;//指定事件的自定义数据，会随着epoll_event一起返回。
ev.events =EPOLLIN;//让epoll监视listensock事件

epoll_ctl的使用

1
2
3

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);//epoll_ctl定义
//oll_ctl的使用
epoll_ctl(epollfd,EPOLL_CTL_ADD,listensock,&ev);//把需要监视的socket加入epollfd

• epfd:为创建的epoll句柄
• op：为操作类型：
  • EPOLL_CTL_ADD：添加
  • EPOLL_CTL_DEL：删除
  • EPOLL_CTL_MOD：修改
• fd：需要操作的目标文件符
• event：需要监控的事件类型

最后声明一组epoll_events来接收返回事件：

1

epoll_event evs[10];//存放epoll返回的事件

后续使用如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

while(true){
    int infds = epoll_wait(epollfd,evs,10,-1);
    
    //返回失败
    if(infds < 0 ){
        perror("epoll()failed");
        break;
    }
    
    //超时
    if(infds == 0){
        perror("epoll() timeout");
        break;
    }
    
    for(int ii =0;ii<=infds;ii++){//遍历返回数组
      if(evs[ii].data.fd == listensock){
           
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        
        printf("accept client(socket = %d)ok.\n",clientsock);
        
        //为新客户端准备可读事件
        ev.data.fd =clientsock;
        ev.events = EPOLLIN;
        epoll_ctl(epollfd,EPOLL_CTL_ADD,clientsock,&ev);
    }else{
            //客户端有事件
        char buffer[1024];
            memset(buffer,0,sizeof(buffer));
            if(recv(evs[ii].data.fd,buffer,sizeof(buffer),0)<=0)
            {
                printf("client(eventfd = %d) disconnected.\n",evs[ii].data.fd);
                close(evs[ii].data.fd); //关闭客户端的socket
                //如果socket被关闭了会自动从epoll句柄中被删除，以下代码不必使用
                //epoll_ctl(epollfd,EPOLL_CTL_DEL,evs[ii].data.fd,0);
            }else{
                printf("recv(eventfd = %d):%S\n",evs[ii].data.fd，buffer);
                send(evs[i].data.fd，buffer,strlen(buffer),0);
            }
    }
    }
    
}

tcp和udp是传输的两种协议他们各有不同，大部分情况下使用的是tcp协议，还有一部分使用的是udp协议

1.TCP和UDP的区别

• TCP

1. TCP面向连接，通过三次握手连接和四次握手断开连接；
2. TCP是可靠的通信方式，通过超时重传、数据校验等方式来确保信息无差错，不丢失，不重复。并且按序到达；
3. TCP把数据当成字节流，当网络出现波动时，连接可能出现响应延迟的问题；
4. TCP只支持点对点通信；
5. TCP报文首部比较大有20字节；

• UDP

1. 无连接，发送前不握手，收后不断开；
2. 不保证可靠，无重传，无确认，无序；
3. 面向报文，一次发一个完整报文，不合并，不拆分；
4. 支持1->1、1->N、N->N；
5. 首部仅8字节，开销小；
6. 无流量控制和拥塞控制，应用层自己限速；

2.TCP保证自身可靠性的方式

• 分片重组与序号管理：发送端按 MSS 分片、接收端按序号重组，天然解决失序/重复问题。
• 到达确认：接收端接收到分片数据时，根据分片的序号对端回复一个确认包（ACK）；
• 超时重发：发送方在发送分片后开始计时，若超时却没有收到对端的确认包（ACK），将会重发分片,可选SACK只重传丢失的块;
• 滑动窗口：TCP中采用滑动窗口来进行传输控制，发送方可以通过滑动窗口大小来确定应该发送多少字节的数据。当窗口为0时，发送方不会再发送数据；
• 重复处理：如果传输的分片出现重复，TCP的接收端会抛弃重复的数据；
• 数据校验：首部与数据反码和校验，出错即丢。
• 拥塞控制：慢启动，拥塞避免，快重传，快恢复，动态调节发送频率；
• 保活计时器：长时间无数据则发探活包，防止‘’死连接‘’占用资源

3.UDP不可靠的原因

• 无连接状态，不跟踪报文是否到达；
• 无序号与确认，无法判断丢包或乱序；
• 无超时重传，发送后不管；
• 无流量/拥塞控制，网络拥塞时仍按原速率发送，加剧丢包；
• 仅可选校验和，出错直接丢弃，不通知发送方。

4.TCP和UDP的使用场景

• TCP使用场景：

TCP实现了数据传输过程中的各种控制，适合对可靠性有要求的场景

如：文件传输、远程登录、邮件、数据库、web等

• UDP使用场景：

可以容忍数据丢失的场景

如：DNS查询、DHCP广播、实时游戏同步

一.大端序小端序

如果数据字节占用内存大小超过1字节，那么CPU数据存储在内存中有两种方式：

大端序（Big Endian）：低位字节存放在高位，高位字节存放在低位；

小端序（Little Endian）：低位字节存放在低位，高位字节存放在高位；

假设从内存0x00000001开始存储十六位进制数0x12345678那么

大端序：

0x00000001 0x12

0x00000002 0x34

0x00000003 0x56

0x00000004 0x78

小端序：

0x00000001 0x78

0x00000002 0x56

0x00000003 0x34

0x00000004 0x12

在我们平常中正常是使用大端序来对齐大多为英特尔cpu。

操作文件的本质是把内存中的数据写入磁盘，在网络编程中，传输数据的本质也是把数据写入文件。

大小端序主要是在不同设备之间传输数据可能会造成问题。

在网络编程中，数据收发时有自动转化机制，不需要程序员手动转换，只有向sockaddr_in结构体成员变量填充数据时，才需要考虑字节问题。

二.网络字节序

为了解决不同设备之间的数据传输问题，采用网络字节序（大端序）。

c语言提供了四个函数，用于在主机字节序和网络字节序之间进行切换：

1
2
3
4

uint16_t htons(uint16_t hostshort); //2字节整数
uint32_t htonl(uint32_t hostlong);//4字节整数
uint16_t ntohs(uint16_t netshort);
uint32_t ntohl(uint32_t netslong);

h:host （主机）

to:转换

n:network （网络）

s:short (2字节 16位的整数)

l:long (4字节 32位整数)

三.IP地址和通讯端口

在计算机中，IPv4的地址用4字节的整数存放，通讯端口用2字节的整数（0-65535）存放。IP地址最高为：255.255.255.255

例如：192.168.190.134 –转化为整数–> 3232284294转化为整数时占用4字节，不转化占用15字节

​ 192 168 190 134

大端：11000000 10101000 10111110 10000110

小段：10000110 10111110 10101000 11000000

四.结构体

• sockaddr结构体：

存放协议族、端口和地址信息，客户端和connect()函数以及服务器的bind()函数需要这个结构体

1
2
3
4

struct sockaddr{
    unsigned short sa_family;//协议族，与socket()函数第一个参数相同，填AF_INET
    unsigned char sa_data[14];//14字节端口和地址。
}

• sockaddr_in结构体：

sockaddr结构体是为了统一地址结构表示方法，统一接口函数，但是操作不方便所以定义了等价的sockarrd_in的结构体，他的大小与sockaddr相同，可以强制转化成sockaddr

1
2
3
4
5
6
7
8
9

struct sockaddr_in{
    unsigned short sin_family;//协议族，与socket()函数第一个参数相同，填AF_INET。
    unsigned short sin_port;//16位端口号，大端序使用htons（整数端口）转换。
    struct in_addr sin_addr; //ip地址结构体
    unsigned char sin_zero[8];//未使用的部分，保持与sockaddr一样的长度
};
struct in_addr{ 
    unsigned int s_addr; //32位ip地址，大端序
}

其中获取32位IP地址大端序获取有如下方案：

以下API在vs2015即被标记为废弃，不建议在新的代码中使用

新版代码位置:

新API

使用gethostbyname函数：

使用域名/主机名/字符串ip获取大端序ip。通常用于客户端

1
2
3
4
5
6
7
8
9

struct hostent *gethostbyname(const char *name);
struct hostent {
    char *h_name;//主机名
    char**h_aliases;//主机所有别名构成的字符串数组，同一个IP可以绑定多个域名。
    short h_addrtype;//主机IP地址类型，例如IPv4（AF_INET）还是IPv6（AF_INET6）
    short h_length;//主机IP地址长度，IPv4地址为4，IPv6地址为16。
    char**h_addr_list;//主机的ip地址，以网络字节序存储。
}
#define h_addr h_addr_list[0]

转换后将大端序地址代码复制到结构体sockaddr_in中的sin_addr成员中

1
2
3
4
5
6
7
8
9
10
11
12

struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port_values);//此处填写服务端通信端口
struct hostent* h;
if((h=gethostbyname(/*域名/主机名/字符串格式的ip*/))==nullptr)
{
    std::cout << 'failed to get gethost' <<std:;endl;
    close(socket);//socket指的是连接
    return -1;
}   
memcpy(&servaddr.sin_addr,h->addr,h->h_length);//指定服务端的ip

使用getaddrinfo代替gethostbyname和gethostbyaddr:

getaddrinfo相比于其他，参数设计非常灵活，支持IPv4/IPv6，多种套接字类型和协议，并且也是线程安全的并且同时也支持跨平台，在Linux中也可以放心替换。

1
2
3
4
5

int getaddrinfo(const char *hostname,
                const char *service,
                const struct addrinfo *hints,
                struct addrinfo **res);

• hostname：一个主机名或者地址串（IPv4的点分十进制串或者IPv6的十六进制串）
• service:一个服务名称或者10进制端口号数串
• hints：可以为空指针，也可以为一个指向某addrinfo结构的指针，调用者在这个结构中填入关于期望返回信息的暗示。如果调用者的服务器支持TCP和UDP，那么调用者可以在这个参数的addrinfo中指定成员ai_socktype设置为SOCK_STREAM使得返回的仅仅适用于数据报套接口的信息。

• result：返回的一个指向addrinfo结构表数据指针，其定义在头文件netdb.h

• addrinfo结构体

1
2
3
4
5
6
7
8
9
10

struct addrinfo {
    int      ai_flags;      // 标志位（AI_PASSIVE 等）
    int      ai_family;     // AF_INET / AF_INET6 / AF_UNSPEC
    int      ai_socktype;   // SOCK_STREAM / SOCK_DGRAM
    int      ai_protocol;   // 0 表示自动
    size_t   ai_addrlen;    // 地址长度
    struct sockaddr *ai_addr; // 指向 sockaddr_in/in6
    char    *ai_canonname;  // 正式主机名
    struct addrinfo *ai_next; // 链表下一节点
};

注意：在使用完addrinfo结构体中一定要手动释放

使用freeaddrinfo(res);

完整示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 向服务器发送连接请求
struct addrinfo server_addr {},*res = nullptr;
server_addr.ai_family = AF_INET;
server_addr.ai_socktype = SOCK_STREAM;

std::string port_str = std::to_string(server_port);
if (getaddrinfo(server_ip.c_str(),port_str.c_str(), &server_addr, &res)) {
    ::closesocket(m_clientfd);
    m_clientfd = -1;
    return false;
}

if (::connect(m_clientfd,res->ai_addr,(int)res->ai_addrlen) == -1) {
    ::closesocket(m_clientfd);
    m_clientfd = -1;
    return false;
}

freeaddrinfo(res);

五.字符串IP与大端序IP转换

把字符串IP转化为大端序IP,用于网络通讯的服务端中：

c语言提供了几个库函数，用于字符串格式的打IP和大端序IP的相互转化，用于网络通讯服务端程序中。

1
2
3
4
5
6
7
8
9
10
11

typedef unsigned int int_addr_t;

//把转换后的ip赋值给in_addr.s_addr。
in_addr_t inet_addr(const char* cp);

//在函数中，把转换后的ip填充到in_addr.s_addr成员中。
int inet_aton(const char* cp,struct in_addr *inp);

//把大端序IP转化成字符串IP,用于在服务端中解析客户端数据ip地址。
char *int_ntoa(struct in_addr in);

服务端用于通信的IP和端口绑定到socket上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(/*指定服务端口*/);
//如果操作系统有多个ipsuoyouip都用于通信
//只有一个ip则将INADDR_ANY换成ip地址即可
//只有一个地址servaddr.sin_addr.s_addr = inet_addr("192.168.101.138"); 字符串地址转化
//以上形式只支持IP地址不支持主机名，域名
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

//绑定服务端得IP和端口(listenfd)
if(bind(listendfd,(struct sockaddr*)&seraddr/*强制转化为sockaddr*/,sizeof(seraddr))==-1)
{
    perror("bind");
    close(listenfd);
    return -1;
}

//socket设置为可连接（监听）
if(listen(listendfd,5)==-1)
{
    perror("listen");
    close(listenfd);
    return -1;
}

相较于gethostbyname通过主机名，域名.inet_addr是直接指定IP不支持主机名和域名获取IP。所以多用于服务端，gethostbyname而在客户端使用。

在以上工作完成之后客户端可以连接服务端发送请求

1
2
3
4
5
6

//客户端
if(connect(sockfd,(struct sockaddr*)servaddr,sizeof(servaddr))==-1){
    perror("connect");
    close(sockfd);
    return -1;
}

三次握手和4次挥手

一. 三次握手

tcp是可靠的连接，在tcp连接时需要进行3次对话（握手）

在服务端进行监听时listen客户端就可以向服务端发送请求connect进行连接，这是首次进行对话，在这个过程中，当客户端调用connect时就会触发三次握手。

当三次握手完成后，客户端和服务端就会建立起一个双向的传输通道。

具体图示如下：

注意：

• 客户端的socket也有端口号，但是不需要关心，所以客户端的socket是随机分配的。

• 服务端的bind()函数，普通用户权限只能使用1024端口以上的端口，而root权限用户则可以使用所有端口。

• listen()函数的第二个参数+1为已连接的队列（ESTABLISHED状态）的大小。超过这个数量的客户端连接到同一个socket进程后的状态会显示为SYN_RECV状态，也称之为半连接状态。

• 上方的图中的状态CLOSED状态是不存在的假想状态。

二. 四次挥手

断开一个TCP连接时，客户端和服务端需要相互总共发送四个包以确认连接的断开。在socket编程中，这一过程由客户端或服务端任意一方执行close()触发

具体流程图如下：

注意：

• 主动断开端在四次挥手后，socket的状态为TIME_WAIT,该状态将持续2MSL(30s/1min/2min)。MSL（Maximum Segment Lifetime）报文在网络上存在的最长时间，超过这个时间报文将被废弃。

• 如果是客户端主动断开，TIME_WAIT的状态几乎不会造成危害,原因如下：

  1. 客户端程序的socket程序很少。
  2. 客户端的端口是随机分配的，不存在重用的问题。

• 如果是服务端主动断开，有两方面危害：

  1. socket没有立即释放。
  2. 端口号只能在2MSL后才能继续使用。

  在服务端程序中，用setsockopt()函数设置socket属性（一定要放在bind()之前）

  1 2 3 4 5 6

  int opt = 1; setsockopt(m_listenfid, SOL_SOCKET, SO_REUSERADDR, &opt, sizeof(opt));

socket函数有关参数解释

在cpp中我们的网络组件都是由以下几个关键接口组成：

服务端：

• socket:网络通信对象

• bind:绑定IP和端口，作为通信入口

• listen:开启监听，等待客户端请求

• accept:接收客户端连接请求
• send:发送数据
• recv:接收数据
• close:关闭连接

客户端：

• socket:网络通信对象
• connect:连接服务器
• send:发送数据
• recv:接收数据
• close:关闭连接

一. socket函数参数

socket创建：

1
2

int socket(int domain,int type,int protocol); //Linux
SOCKET socket(int domain,int type,int protocol); //Windows

创建成功返回一个有效的socket，失败返回-1，errno被设置。

参数不错的情况下基本不会失败。

单个进程中创建的socket数量与受系统参数open files的限制（socket本质也是文件描述符）

• domain家族:

  1. AF_INET：IPv4互联网协议族
  2. AF_INT6：IPv6互联网协议族
  3. AF_LOCAL：本地通信协议族
  4. AF_PACKET：内核底层协议族
  5. AF_IPX：IPX Novell协议族

• type数据传输类型：

  1. SOCK_STREAM面向连接的socket：
     • 数据不会丢失
     • 数据顺序不会错乱
     • 双向通道
  2. SOCK_DGRAM无连接的socket:
     • 数据可能会丢失
     • 数据顺序可能会错乱
     • 传输效率更高

• protocol最终使用协议：

IPv4网络家族协议中，数据传输方式为SOCK_STREAM的协议只有IPPROTO_TCP，数据传输方式为SOCK_DGRAM协议的只有IPPROTO_UDP。

此处参数也可以填0编译器可自动识别

TCP和UDP

1
2

socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);

二. bind函数参数

1
2

int bind(int sockfd,const struct sockaddr *addr,socklen_t addrlen);//Linux
int bind(SOCKET sockfd,const struct sockaddr* addr,socklen_t addrlen);//windows

给socket绑定一个地址，这样client对这个地址收发相应的数据就能和socket关联如果绑定失败会返回-1,erron被设置

在服务端中必须要进行调用，在客户端中不需要调用，也可以调用，如果不调用则由系统自动绑定本机地址和随机分配端口进行连接

• sockfd:socket文件描述符
• addr:构建sockaddr的结构体包含IP端口等信息
• addrlen:结构体addr的参数长度

三. listen函数参数

1
2

int listen(int sockfd,int backlog);//Linux
int listen(SOCKET sockfd,int backlog); //windows

当服务器开启监听后会等待客户端的连接请求，如果开启失败会返回-1,erron被设置

同样在服务器中必须要被调用以用来接收请求

• sockfd:socket文件描述符
• backlog:指定了服务器排队的最大连接数，当客户端发起请求时，服务器需要时间来处理请求，因此会有一个队列来存储这些暂时不能处理的请求。如果并发量小一般可以设置为10-20。如果将其设置为SOMAXCONN则是由系统来决定请求队列长度，这个值一般比较大，可能是几百甚至更多。当队列满后不再接收新的请求。

四. accept函数参数

1
2

int accept(int sock,struct sockaddr* addr,socklen_t *addrlen);//Linux
SOCKET accept(SOCKET sock,struct sockaddr* addr ,socklen_t *addrlen); //windows

accpet是专门用来接收客户端请求用的，与listen配套使用

• sock：服务器套接字（这里是服务器的而不是客户端的）
• addr：保存的是客户端的相关信息。后续要使用addr进行与客户端的通讯
• addrlen：结构体的大小。

跟listen进行区分，在listen只是开启了监听，而accept才是真正进行接收工作。accept会阻塞程序运行，直到由新的请求

五. send/recv函数参数

1
2
3
4
5
6

//Linux
ssize_t send(int sockfd,const void* sendbuffer,size_t nbytes,int flag);
ssize_t recv(int sockfd,void* recvbuffer,size_t nbytes,int flag);
//Windows
int send(SOCKET sockfd,const char* sendbuffer ,int nbytes,int flag);
int recv(int sockfd,char* recvbuffer,size_t nbytes,int flag);

send和recv都是用来对字节流的传输和接收，其中Linux中还有read()和write()的使用如下：

1
2
3

//仅限Linux
ssize_t write(int sockfd,const void* sendbuffer,size_t nbytes);
ssize_t read(int sockfd ,void* recvbuffer,size_t nbytes);

两者明显的区别是write和read没有flag参数，然而在使用时基本使用send和recv因为功能更全面且两个平台均支持，所以兼容性也更好。

• sockfd:目标端套接字
• sendbuffer:要发送的消息（win端要转化为字符数组类型地址，Linux可以直接发送结构体）

• recvbuffer:要发送的消息（win端要转化为字符数组类型地址，Linux可以直接发送结构体）

• nbytes:要发送消息的字节长度

六. close函数

1
2

close(int sockfd);//Linux
closesocket(SOCKET sockfd);//Windows

用来关闭连接使用，关闭自身socket对象。

TCP缓存

系统为每个socket创建了发送缓冲区和接收缓冲区，应用程序调用send()或者write()函数发送数据的时候，内核吧数据从应用进程拷贝socket的发送缓冲区中；应用程序调用recv()或者read()函数接收数据的时候，内核把数据从socket的接收缓冲区拷贝进应用进程中。

发送数据即把数据放入发送缓存区。

接收数据即从接收缓冲区中取数据。

查看socket缓存大小:

1
2
3
4
5
6
7
8
9
10
11

int bufsize = 0;
socklen_t optlen = sizeof(bufsize);

//发送缓冲区大小
getsockopt(sockfd ,SOL_SOCKET,SO_SNDBUF,&bufsize,&optlen);
std::cout << "send bufsize = " << bufsize << std::endl;

//接收缓冲区大小
getsockopt(sockfd ,SOL_SOCKET,SO_RCVBUF,&bufsize,&optlen);
std::cout << "recv bufsize = " << bufsize << std::endl;

注意：

send():函数在发送缓存区或者对端的接收缓存区满了时会阻塞。

• Nagle算法

在TCP协议中无论发送多少数据，都要在数据前面加上协议头，同时对方接收到数据后也要回复ACK表示确认，为了尽可能的利用网络带宽，TCP每次希望都能够以MSS(Maximum Segment Size,最大报文长度)，的数据块来发送数据。

Nagle 算法就是为了尽可能发送大块数据，避免网络中充斥着小数据块

Nagle 算法的定义是：任意时刻，最多只有一个违背确认的小段，小段是指小于MSS的数据块，违背确认是指一个数据块发送出去后，没有收到对端回复的ACK。

• ACK延迟机制

TCP协议中不仅仅有Nagle算法，还有一个ACK延迟机制：

当接收端收到数据后，并不会马上向发送端回复ACK,而是延迟40ms后再回复，它希望再40ms内接收端会向发送端回复应答数据，这养ACK可以和应答数据一起发送，把ACK稍带过去。

如果TCP连接的一段启用了Nagle算法，另一端启用了ACK延迟机制，而发送的数据包又比较小，则可能出现这样的情况：发送端在等待上一个包的ACK，而接收端正好延迟了此ACK，那么这个正要发送的包就被延迟了40ms。

解决方案

开启TCP_NODELAY,开启后就是禁用Nagle算法

1
2
3

#include <netinet/tcp.h>
int opt = 1;
setsockopt(sockfd,IPPROTO_TCP,TCP_NODELAY,&opt,sizeof(opt));

对时效要求高的系统中，如联机游戏就会禁用Nagle算法。

线程的创建和使用

​ 线程库中创建多线程的库是thread库,基本的线程创建是使用std::thread,如果创建了线程但是没有等待线程结束就会报错，此时有两种方式，第一种使用join（）方法让主线程等待子线程完成工作。第二个就是分离子线程使其单独在后台运行，方法为detach（）。当整个进程结束时整个子线程的资源才会被跟着回收。

​ 其中每个线程只能使用一次join，如果多次使用就会抛出异常，其中方法joinable()就是判断是否可以进行join或者detach（）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <iostream>
#include <thread>
#include <string>


void printStr(std::string str) {
std::cout <<  str << std::endl;
}

int main() {


// 创建线程 
std::thread thread1(printStr,"Hello_world");

//分离线程(主进程结束后子线程不会报错但是也会被强制结束)
//thread1.detach();

//主线程等待子线程结束
//thread1.join();

//返回bool判断是否可以调用join或者detach
//join只能使用一次，再次使用会报错
bool isjoin = thread1.joinable();
if (isjoin)
thread1.join();//或者thread1.detach();
return 0;
}

线程中的无定义行为（Undefined Behavior，UB）

cpp程序中无定义行为(UB)是一种非常严重的程序错误其中主要是两个方面的原因：

1. 对象生命周期的规划1. 指针失效

第一点中其中对象生命周期的规划主要是作用域中体现，如当一个局部变量在所在作用域执行完后其生命周期就结束了，结束后其原来的占用地址内存被回收，那一块内存就不再是原来的内容了。

第二点中是指针的失效，即原来的指针在解引用后如果再次访问的话就造成了UB，此时会有以下几个情况

• 程序继续运行，但是读取的内容是垃圾值无效数值。
• 触发系统保护，抛出SIGSEGV。
• 彻底优化掉本次访问，直接相当于略过。

那么再加上线程运行后会把这个问题放大，当主线程执行完毕后很多资源被释放掉后子线程就及其容易进入UB，本身在线程中执行时间执行级别会被放大，其问题发生概率也会被直接放大。

在整个程序周期中有以下几点可以尽量避免程序触发UB:

1. 延长生命周期
2. 主线程等待，尽量使用join避免使用或者少使用detach
3. 将需要使用的内容直接拷贝而非直接引用

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
#include <thread>


void func1(int& x){
    x+=1;
}

void func2(){
    int a = 1;
    std::thread t(func1,std::ref(a));//同样触发UB，在线程启动后a的资源就被释放了
}

void func3(int*x){
    std::cout << *x << std::endl;
}

int main(){
    int a = 1;
    std:;thread t1(func1,a);//这里会报错或者会出
    //如果想传递这个参数需要使用std::ref打包，如下：
    std::thread t2(func1,std::ref);
    
    /*
    这个示例现实的值并非我们传入的1，也可能崩溃，也有概率会输出1，看是否是在delete之前就把指令执行完了
    */
    int* s = new int(1);
    std::thread t3(func3,s);
    delete s;
    
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

类对象UB示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
#include <thread>
#include <memory>

class MyClass{
    public:
    void func(){
        std::cout << 'Thread' <<std::this_thread::get_id()
            << "shared" <, std::endl;
        std::cout << "Thread" << std::this_thread::get_id()
            <<"finished" << std::endl;
        
    }  
};

int main(){
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    std::thread t(&MyClass::func,*obj);
    t.join();//与上述例子其实都差不多
    return 0;
}

可以使用智能指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>
#include <thread>
#include <memory>

class Cls{
    public:
    void foo(){
        std::cout << "Hello" << std::endl;
    }
}

int main(){
    std::shared_ptr<A> a = std::make_shared<A>();
    std::thread t(&a::foo,a);
    return 0;
}
    

互斥锁（量）解决多线程共享问题

数据共享问题

​ 在多个线程中共享数据时需要注意线程安全问题，如果多个线程同时访问一个变量并且至少其中一个线程对其进行了写操作，那么就会出现数据竞争问题，数据竞争问题可能会导致程序崩溃、产生未定义结果、或者得到错误的结果。

​ 为了避免数据竞争问题，需要有同步机制来确保多个线程之间共享数据的安全。常见的同步机制包括互斥量，条件变量，原子操作等。

以下为简单示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
#include <thread>

void funcadd() {
for (int i = 0; i < 1000; i++) {
a += 1;
}
}


int main(){
    
    std::thread t1(funcadd);
std::thread t2(funcadd);

t1.join();
t2.join();

std::cout << a << std::endl;
    
    return 0;
}

运行以上代码后基本不会得到预期的2000数值且每次运行结果都很可能会不一样

正确写法是在funcadd中加一个锁，具体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

std::mutex mtx;
int a = 0;

void funcadd() {
for (int i = 0; i < 1000; i++) {
mtx.lock();
        a += 1;
        mtx.unlock();
}
}

根据运行结果可知，只要当多线程运行的数值结果能与单线程运行时得到相同的结果时这个多线程运行就是安全的。

死锁

值得注意的是在锁的操作中还有个死锁的情况

场景：

• 线程A 需要操作lk1 和lk2
• 线程B需要操作lk2 和lk1

操作：

​ 让程序直接运行这两个线程就会出现死锁的状态。

原因：

​ 当线程A,B执行后由于两者是并行运行，所以会有线程A拿到lk1的所有权，线程B拿到lk2的所有权，当线程A准备申请lk2的所有权时因为在B手中所以陷入等待。同样，线程B也在等待线程A,于是两者就永远等待下去了。就是死锁。

场景复现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

std::mutex m1,m2;

void func1() {
m1.lock();
std::this_thread::sleep_for(std::chrono::seconds(2));
m2.lock();
m2.unlock();
m1.unlock();
}

void func2() {
m2.lock();
std::this_thread::sleep_for(std::chrono::seconds(2));
m1.lock();
m1.unlock();
m2.unlock();
}

int main(){
    std::thread t1(func1);
std::thread t2(func2);

t1.join();
t2.join();

std::cout << "执行完成" << std::endl;
    return 0;
}

在以上代码中两个锁永远没有释放，双方一直在等待对方解开锁就造成了死锁

模板锁的用法

有两个主要的模板锁分别是std::lock_guard和std::unique_lock这两者各有自己的不同点主要为：

• lock_guard：用于保护数据共享防止多个线程同时访问同一资源而导致的数据竞争问题。

1. 当构造函数被调用时，该互斥锁会被自动锁定。
2. 当析构函数被调用时，该互斥锁会自动解除锁定。
3. std::lock_guard对象不能被复制或者移动，因此他只能在局部作用域中使用。

用法示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

std::mutex mtx;
int sum =0;

void func(){
    for(int i =0 ;i<50;i++){
        std::lock_guard<std::mutex> lk(mtx);
        sum++;
    }
}

int main(){
    std::thread t1(func);
    std::thread t2(func);
   t1.join();
    t2.join();
    return 0;
}