Linux系统编程

Linux常见目录

Bash解析器常用快捷键

1.tap键

补齐命令，补齐路径，显示当前目录下的所有目录

2.清屏 clear

3.中断进程 ctrl+c

4 遍历输入的历史命令箭头上（ctrl+p）箭头下(ctrl+n)

5 光标相关操作

光标左移： ctrl+b（箭头左）

光标右移： ctrl+f(箭头右)

移动到头部: ctrl+a(home键)

移动到尾部：ctrl+e(end键)

6字符删除

删除光标前面的字符：ctrl+h(Backspace)

删除光标后面的字符：ctrl+d

光标后面的字符即光标覆盖的字符

删除光标前的所有内容：ctrl+u

删除光标后的所有内容：ctrl+k

终端相关快捷键

（终端一定要选中）

ctrl+shift+N 新建一个终端

ctrl+shift+T 在终端里新建一个标签

ctrl+D 关闭当前一个终端

内建命令和外部命令对比

内建命令 vs 外部命令 对比总结

命令类型查看方法

使用type命令

1

type [选项] 命令名

使用 -a 显示所有同名命令（包括 alias、builtin、文件）

使用 -t 显示类型（简洁）

Linux命令格式

1

命令 [选项] [参数]

选项类型说明

帮助文档查看方法

如果是内建命令（可以通过之前的type命令查看）使用 help +内建命令

1

help pwd

如果是外部命令 对应命令名 –help

1

ls --help

man 是 Linux 中最常用的命令之一，全称是 manual（手册），用于查看各种命令、函数、配置文件的使用说明。它是学习和查找 Linux 命令最权威的工具。

man 命令基本语法：

1

man [选项] [命令名或函数名]

man 手册的 9 个部分（章节）

常用选项

目录相关命令

pwd

用于显示当前终端所在的工作目录（即当前绝对路径）。

cd

1

cd [目录路径]

常见用法示例

mkdir

用于创建新目录的命令，创建不了已存在目录。

1

mkdir [选项] 目录名

mkdir test 在当前目录下创建test文件夹

mkdir /tmp/test

mkdir file{1..100}在当前目录创建100个文件夹，file1,file2,file3…file100

mkdir “file{1..100}”在当前目录创建file{1..100}文件夹，只会创建一个。

mkdir “a b” 在当前目录创建a b一个文件夹。

mkdir a b 在当前目录创建a b两个文件夹。

rmdir

用法和mkdir相同

用于删除空目录的命令

Linux文件类型

常用的文件类型有七种：普通文件，目录文件，设备文件，管道文件，链接文件和套接字。

普通文件 是 Linux 中最常见的一类文件，主要用于存储用户数据。包括：

• 文本文件（如 .txt, .c, .py）
• 二进制文件（如 可执行程序、图片、音频等）
• 脚本文件（如 .sh, .py，可以被解释执行）

在 Linux 中，目录文件（Directory File） 是一种特殊的文件类型，用来组织和存放文件和其他目录（子目录）。
它本质上是一个保存了文件名和 inode 编号之间映射关系的文件。

设备文件（Device File）是 Linux 中用于访问硬件设备的接口，本质上就是一种特殊的文件，程序通过它来与硬件设备通信。

设备文件通常位于 /dev 目录中。

常见设备文件举例

管道文件（或称命名管道，FIFO = First In First Out）是一种特殊文件，用于在不同进程之间传输数据。
写入管道的数据会按顺序被读取，类似“排队喝水”的水管，先进先出。

管道文件与匿名管道不同之处在于它有名字，存在于文件系统中（通常创建在某个路径下），因此不同进程不必有父子关系也能通信。

链接文件 是指向另一个文件的引用，常用于：

• 创建多个路径指向同一个文件（节省空间）
• 为长路径或常用文件创建别名（提高效率）
• 实现共享与替代功能

在 Linux 中，你可以使用 ls -l 命令来区分各种文件类型。ls -l 输出的每一行开头的第一个字符表示文件类型。下面是 七种常见文件类型及其 ls -l 显示符号：

七种常见文件类型及其标识

文件相关命令

ls命令

ls -l命令会输出长格式

1
2

权限       硬链接数 拥有者 所属组  大小    修改日期      文件名
drwxr-xr-x   2    user   user  4096   Jun 21 13:00  mydir

对权限部分说明一下权限部分总共10个字符

文件类型标识（第1个字符）

权限字符说明（2-10位置）

三组权限详解

什么是通配符？

通配符是一种简化文件名匹配的符号，用于在命令中匹配多个文件或目录。它可以让你不用输入完整文件名，就能选中符合规则的文件。

常用的通配符类型

touch命令

touch 是用来 创建空文件 或 更新已有文件的时间戳 的命令。

1

touch file.txt

如果 file.txt 不存在，会被创建为空文件；如果存在，文件时间被更新。

1

touch file1.txt file2.txt file3.txt

一次创建或更新多个文件。

1
2

touch file{2,3,4}#同时创建file2,file3,file4三个空文件和mkdir file{1..100}用法是一样的。
touch "file{2,3,4}"#创建file{2,3,4}这一个文件。

cp命令

cp 是 Linux 中用于 复制文件或目录 的命令。

rm命令

是用于在 Linux 中 删除文件和目录 的命令。注意：rm 删除后不会进入回收站，无法轻易恢复，请务必小心使用。

mv命令

移动文件或目录 到新位置，重命名 文件或目录。

文件内容查看相关命令

cat命令

用于 查看、创建、合并文件 内容，常用于快速查看文本文件内容。

less命令

用于分页显示文件内容的命令，支持 向前/向后翻页浏览，适合查看大型文本文件。它比 cat 更强大，且不会一次性加载全部内容到内存中。

使用时常用快捷键（进入 less 后）

head命令

head 用于345

tail命令

用于显示文件的最后几行内容，默认是最后 10 行。常用于：

• 查看日志尾部；
• 实时监控文件内容变化（配合 -f 选项）；
• 截取文件结尾部分数据。

1
2
3

tail /etc/passwd #默认显示后十行
tail -n 30 文件名 #显示后30行内容
tail -c 30 文件名 #显示后30个字符

du和df命令

du命令

查看目录或文件占用的磁盘空间，会考虑磁盘块对齐、文件系统元数据、软链接等因素。

1

du -sh 文件名/目录

1
2
3

echo "hello" > file.txt
ls -l file.txt      # 显示 6 bytes
du -sh file.txt     # 显示 4.0K

df命令

查看整个磁盘的使用情况

1
2

df -h # 显示所有文件系统的使用情况（人类可读格式）
df -h /home # 查看 /home 所在分区的磁盘使用情况

查找相关命令

find

find 是 Linux 中功能非常强大的文件搜索命令，它可以根据名称、类型、时间、大小、权限等多种条件在目录中递归查找文件，还可以执行删除、移动、打印等操作。

1

find [搜索路径] [搜索条件] [处理动作]

按文件名查询：使用参数 -name

1

find ./ -name "*.txt" #查找当前路径下符合后缀是。txt的文件

按文件大小查询：使用参数 -size

1

find ./ -size +100k

+100k 表示大于100k的文件

-100k表示小于100k的文件

100k 表示等于100k的文件

大小方面：k小写，M大写

查询大小范围

1

find ./ -size +50k -size -100k

按文件类型查询：使用参数 -type

1

find ./ -type f #查询当前的普通文件

grep

grep 是 Linux 中非常常用的文本搜索工具，用于在文件或标准输出中查找匹配的字符串，功能强大，灵活，适合日志分析、配置文件搜索、编程辅助等场景。

1

grep [选项] "模式" [文件]

1
2
3
4

grep -i "root" /etc/passwd #不分大小写，在passwd查找root
grep -w "hello" /etc/passwd #在passwd查找完全匹配hello单词的行
grep -r "u_char" ./  #递归搜索当前目录下的符合u_char的行
grep -i "hello" /etc/passwd --color=auto #在/etc/passwd文件中找hello并且忽略大小写，然后高亮显示匹配的关键字

管道

管道（|）一个命令的输出可以通过管道作为另一个命令的输入。

1

ifconfig | grep "ens33" #在ifconfig输出的文字查找存在ens33的行

压缩包管理

tar

把一系列文件归档到一个文件，也可以把档案文件解开以恢复数据。

1

tar [选项] -f [文件名.tar] [要打包或解压的文件/目录]#f必须放到选项的最后

1
2
3

tar -cvf sysctl.tar sysctl #打包文件，但是不压缩
tar -xvf sysctl.tar #解包文件
tar -tvf sysctl.tar #查看压缩文件内容

gzip

对单个文件进行压缩或解压，压缩率高、速度快，默认生成 .gz 文件。

tar和gzip命令结合使用实现文件打包，压缩。

tar只负责打包文件，但不压缩，用gzip压缩tar打包后的文件，其扩展名一般为xxx.tar.gz。

gzip单独使用，只可以对文件压缩和解压，不可以对目录。

1

gzip test1 test2 #不保留源文件压缩。 

tar和gzip结合对目录压缩

1
2
3

tar -czvf sysctl.tar.gz sysctl #打包和压缩文件
tar -xzvf sysctl.tar.gz #解包和解压文件
tar -xzvf sysctl.tar.gz -C /temp #解包和解压文件到temp目录

bzip2

和gzip一样和tar结合。

1
2

tar -cjvf test.tar.bz2 test #生成一个bz2压缩包
tar -xjvf share.tar.bz2 #解压

zip和unzip

通过zip压缩文件的目标文件不需要指定扩展名，默认扩展名为zip。

1
2

zip [选项] 目标文件（没有扩展名）源文件/目录
unzip -d 解压后目录文件 压缩文件 #-d解压到指定目录

文件权限管理

访问权限说明：

读权限（r）

对文件而言，具有读取文件内容的权限；对目录而言，具有浏览目录的权限。

写权限（w）

对文件而言，具有新增，修改文件内容的权限；对目录而言，具有删除，移动目录内文件的权限。

可执行权限（x）

对文件而言，具有执行文件的权限；对目录而言，该用户具有进入目录的权限。

通常。Unix/Linux系统只允许文件的属主（所有者）或root用户改变文件的读写权限。

chmod

chmod（change mode）是 Linux/Unix 系统中用于修改文件或目录权限的命令。它支持两种权限设置方式：数字方式和符号方式。

1

chmod [选项] 模式 文件名

符号方式：

1
2
3

chmod u/g/o/a +/-/= rwx 文件 #+添加权限 -撤销权限 =设定权限 u/g/o对应的是拥有者，同属组，其他。
chomd o+w a #向a的其他用户添加写权限
chomd u=rw,g=r,o=r a#把a的拥有者权限为re,同属组权限为r,其他用户权限为r。

数字方式：

1
2
3
4
5
6

#由于rwx通过二进制来区分 rwx就是111，十进制为7
#rwx   7
#rw-   6
#r--   4
#r-x   5
chomd 0777 a#把a的对应用户的权限变为rwx.

chown

chown 是 Linux/Unix 中用于更改文件或目录 所属用户（owner） 和 所属用户组（group） 的命令。

1

chown [选项] [新用户][:[新用户组]] 文件/目录

新用户：新的文件拥有者

新用户组：新的用户组（可选）

需要 sudo 权限（普通用户只能修改自己拥有的文件）

1
2
3
4

#把文件所有者修改为root用户
sudo chown root a
#把文件所属者改为yustone,所属组改为root
sudo chown yustone:root a

软件安装和卸载

使用包管理器安装和卸载

Ubuntu / Debian 系列

安装

1
2

sudo apt update          # 更新软件源
sudo apt install 软件名  # 安装软件

卸载

1
2

sudo apt remove 软件名           # 删除程序但保留配置文件
sudo apt purge 软件名            # 连配置文件一并删除

离线软件包安装：

1

sudo dpkg -i package.deb

离线软件包卸载：

1

sudo dpkg -r 软件名

使用 Snap 安装（跨平台容器化安装方式）

1

sudo snap install 软件名

使用 Snap 卸载（跨平台容器化安装方式）

1

sudo snap remove 软件名

从源代码编译安装

1
2
3

./configure
make
sudo make install

重定向

主要是把命令输出的内容（之前是屏幕）输入到文件里。

1
2
3
4
5
6
7

ls /etc/passwd > output.txt #标准正确输出重定向到output.txt（这里是覆盖原文件）
ls /etc/passwd >> output.txt #标准正确输出追加重定向到output.txt(这里是追加)
llll 2> error.txt #标准错误输出重定向到error.txt(这里是覆盖原文件)
llll 2>> error.txt #标准错误输出追加重定向到error.txt
lll 2> /dev/null #标准错误输出重定向到黑洞
ls ddddd /etc/passwd &> /dev/null #标准正确输出和标准错误输出全部重定向到黑洞。
ls ddddd /etc/passwd &>> output.txt #标准正确输出和标准错误输出以追加的方式全部重定向到output.txt.

其他命令

tree

tree以树状形式查看指定目录内容。

1

tree 目录

ln

ln命令主要用于创建链接文件。

链接文件分为软链接和硬链接：

硬链接只能链接普通文件，不能链接目录。软链接不占用磁盘空间，源文件删除则链接失效。

1
2

ln 源文件 链接文件 #硬链接
ln -s 源文件 链接文件 #软链接

如果没有-s选项代表建立一个硬链接文件，两个文件占用同一块的硬盘空间，即使删除了源文件，链接文件还是存在，所以-s比较常用。如果软链接文件和源文件不在同一目录，源文件最好使用绝对路径，不要使用相对路径。软链接文件存储的是目标文件的路径。

vim

vim 是一款强大的 文本编辑器，常用于 Linux / Unix 系统编程、脚本编辑、配置文件修改等场景。它是 vi 的增强版本，具有更强的功能，比如语法高亮、代码折叠、多窗口、多标签支持等。

vim的三种模式

普通模式（Normal Mode）

默认启动模式，你一打开 Vim 就是在这个模式。

作用：浏览、复制、剪切、粘贴、删除、移动光标、跳转、执行命令等。

常用命令：

插入模式（Insert Mode）

按 i、a、o 等从普通模式进入插入模式。

作用：输入文字、写代码、编辑内容。

常用进入方式：

退出插入模式：按 Esc 返回普通模式。

命令模式（Command-Line Mode）

按 : 从普通模式进入命令模式。

用于输入各种操作命令，如保存、退出、查找、替换等。

常用命令：

gcc编译器

GCC（GNU Compiler Collection）是由 GNU 项目开发的一组编译器，最初是为了 C 语言开发的，现在支持多种编程语言

gcc编译器从拿到一个c源文件到生成一个可执行文件，中间一共经历了四个步骤：

1
2
3
4
5
6
7
8

gcc -E hello.c -o hello.i
gcc -S hello.i -o hello.s
gcc -c hello.s -o hello.o
gcc hello.o -o hello
./hello #执行
gcc 源文件 -o 可执行文件 #一步到位
gcc hello.c -o hello
./hello

1
2
3

gcc -Wall test.c #显示所有的警告信息
gcc -Wall -Werror test.c #把警告信息当作错误处理
gcc tmp.c -DDEBUG #可以用来区分测试版和发布版,DEBUG是定义的宏

静态链接和动态链接

静态链接：由链接器在链接时把库的内容加入到可执行程序中。

优点：对运行环境的依赖较小，具有较好的兼容性。

缺点：生成的程序比较大，在装入内存消耗更多的时间。库函数有了更新，必须重新编译。

动态链接：链接器在链接时仅仅建立和所需库函数的链接关系，在程序运行时才将所需资源调入可执行程序。

优点：在需要的时候才会调入对应的资源函数。简化程序的升级，有着较小的程序体积，实现进程间的资源共享（避免重复拷贝）

缺点：依赖动态库，不能独立运行，动态库依赖版本问题严重。

静态和动态编译对比

我们编写的应用程序大量用到了库函数，系统默认采用动态链接的方式进行编译程序，若想采用静态编译，加入-static参数。

1
2

gcc test.c -o test
gcc -static test.c -o test

静态编译是要比动态编译程序大的多。

静态库和动态库

静态库可以认为是一些目标代码的集合，是在可执行程序运行前就已经加入到执行码中，成为执行程序的一部分。按照习惯，一般以”.a”作为文件后缀名。静态库的命名一般分为三个部分：前缀：lib,库名称：自己定义。后缀：.a。最终静态库的名字为libxxx.a

静态库制作：

1
2
3
4
5

gcc -c add.c -o add.o #-c是只编译不链接输出.o文件
gcc -c sub.c -o sub.o
gcc -c mul.c -o mul.o
gcc -c div.c -o dic.o
ar -rcs libtest.a add.o sub.o mul.o div.o#使用打包工具ar将准备好的.o文件打包为.a文件libtest.a

在使用ar工具需要添加参数：rcs

r更新，c创建，s建立索引

静态库使用：

静态库制作完成之后，需要将.a文件和头文件一起发布给用户。假设测试文件是main.c,静态库文件为libtest.a，头文件为head.h

编译命令：

1

gcc main.c -L./ -I./ -ltest -o main#注意这里链接库的名字

-L：表示要连接的库所在目录。

-ltest:指定链接时需要的库，去掉前缀和后缀

-I(这里是大写的i):表示要连接的头文件目录

动态库制作

共享库在程序编译时并不会被链接到目标代码中，而是在程序运行时才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。

动态库在程序运行时才被载入，也解决了静态库对程序的更新，部署和发布的再次编译的问题，用户只需要更新动态库即可，增量更新。

一般以”.so”作为文件后缀名。共享库的命名一般分为三个部分：前缀lib,库名称:自己定义，后缀：.so。所以最终的动态库的名字应该为：libxxx.so。

1
2
3
4
5
6
7
8
9
10
11

#生成目标文件，此时要加编译选项：-fPIC(fpic)参数-fPIC创建与地址无关的编译程序（pic,position independent code）,是为了能在多个应用程序间共享。
gcc -fPIC -c add.c
gcc -fPIC -c sub.c
gcc -fPIC -c mul.c
gcc -fPIC -c div.c
#生成共享库，此时要加链接器选项：-shared(指定生成动态链接库)
gcc -shared add.o sub.o mul.o div.o -o libtest.so
#通过nm命令查看对应的函数
nm libtest.so | grep "add"
#通过ldd命令查看可执行文件依赖的动态库
ldd test

动态库使用

引用动态库编译成可执行文件（和静态库一样）

1

gcc main.c -L./ -I./ -ltest -o main#注意这里链接库的名字

这一步是可以过的，但是到了，执行main时发现找不到对应文件。第一种就是把libtest.so复制到/lib里（需要sudo,这个方法不推荐，最好不要动Linux原本文件，覆盖了就不好玩了。）

1

gcc main.c -I./ -ltest -o main#注意这里链接库的名字,执行可执行文件就可以执行了，这种方法不推荐

动态库加载失败问题解决

当系统加载可执行代码，能够知道其所依赖的库的名字，但还需要知道其绝对路径。此时就需要系统动态载入器（dynamic linker/loader）。对于elf格式的可执行程序，是由ld-linux.so*来完成，他先后搜索elf文件的DT_RPATH段—环境变量LD_LIBRARY_PATH—/etc/ld.so.cache文件列表—/lib/,/usr/lib目录找到库文件后将其载入内存。

拷贝自己制作的共享库到/lib或者/usr/lib(不能是/lib64目录)

临时设置LD_LIBRARY_PATH(只在当前终端生效):

1

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:库路径#在原环境变量追加新的变量，库路径为绝对路径。

永久设置:把export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:库路径这段话，设置到~/.bashrc

1

source ~/.bashrc #让配置文件生效

除了以上三种还有两种将其添加到/etc/ld.so.conf,这里只需要添加绝对路径，然后sudo ldconfig -v使路径生效。

还有使用符号链接，但一定要使用绝对路径。

1

sudo ln -s 库文件的绝对路径 /lib/库文件

GDB调试器

GDB主要完成下面四个功能：

1.启动程序，可以按照你的自定义的要求随心所欲的运行程序。

2.可让被调试的程序在你指定的断点停住。

3.当程序被停住时，可以检查此时你的程序中所发生的事。

4.动态的改变你程序的执行环境。

生成调试信息

一般来说GDB主要调试的是C/C++的程序，要调试C/C++的程序，首先在编译时，我们必须把调试信息加到可执行文件中。使用编译器（cc/gcc/g++）的-g参数可以做到这一点。

1
2

gcc -g hello.c -o hello
g++ -g hello.c -o hello

启动GDB

启动gdb:gdb program

program也就是你的执行文件，一般在当前目录下。

设置启动参数:启动后设置

1
2
3

set args #可指定运行参数
set args 10 20 30 40 "hello world"
show args #命令可以查看设置好的运行参数

启动程序：

run:程序开始执行，如果有断点，停在第一个断点处。

start:程序向下执行一行。

n:执行下一步。

显示源代码

用list（也可直接打l）命令来打印程序的源代码。默认打印10行。

1
2
3

list function#显示函数名为function的函数的源码
set listsize count #设置一次显示源码的行数默认是10行
show listsize #查看当前listsize的设置

断点操作

简单断点:

break设置断点，可以简写为b

1
2

b 10 #设置断点，在源程序第十行
b func #设置断点，在func函数入口处

多文件设置断点

1
2
3
4

break filename:linenum #在源文件filename的linenum行处停住
break filename:function #在源文件filename的function函数的入口处停住
break class::function或者function(type,type) #在类class的function函数入口处停住
break namespace::class::function #在名称空间为namespace的类class的function函数的入口处停住。

查询所有断点

1
2
3
4

info b
info break
i break
i b

条件断点

一般来说，为断点设置一个条件，我们使用if关键词，后面跟其断点条件。

设置一个条件断点：

1

b test.c:8 if Value == 5 #对test.c文件的当变量Value满足为5时，在test.c文件的第8行产生断点

维护断点

delete 范围 删除指定的断点，其简写命令为d。如果不指定断点号，则表示删除所有的断点。

1

d 10-12 #删除编号为10-12的断点。编号可以使用i b命令查看

比删除更好的一种方法时disable停止点，disable了的停止点，GDB不会删除，当你还需要时，enable即可。

1
2

disable 断点编号 #使指定断点无效，简写命令是dis。如果什么都不指定，表示disable所有的停止点。
enable 断点编号 #使无效断点生效，简写命令是ena。如果什么都不指定，表示enable所有的停止点

调试代码

1
2
3
4
5
6
7

run #运行程序，可简写为r。程序开始执行，如果有断点，停在第一个断点处。
next #单步跟踪，函数调用当作一条简单语句执行，可简写为n。
step #单步跟踪，函数调用进入被调用函数体内，可简写为s。
finish #退出进入的函数
until #在一个循环体单步跟踪时，这个命令可以运行程序直到退出循环体，可简写为u。
continue #继续运行程序，停在下一个断点的位置，可简写为c。
quit #退出gdb,可简写为q。

数据查看

1
2
3

#查看运行时的数据
#print打印变量，字符串，表达式等的值，可简写为p。
p count #打印count的值

自动显示

可以设置一些自动显示的变量，当程序停住时，或在你单步跟踪时，这些变量会自动显示。相关的GDB命令是display

1
2
3
4
5
6
7

display 变量名 #在run启动程序后，使用该命令。
info display #查看display设置的自动显示的信息（可以看到对应变量名的编号）
undisplay num #info display是显示的编号 使对应编号的自动显示功能失效。
delete display dnums #删除自动显示，dnums意为所设置好了的自动显示的编号。如果要同时删除几个，编号可以用空格分隔，如果要删除一个范围的编号，可以用减号表示。
disable display dnums
enable display dnums
disable和enable#不删除自动显示的设置，而只是让其失效和恢复。

查看修改变量的值

1
2
3

ptype width #查看变量width的类型
p width #打印变量width的值 p是print命令的缩写。
set var width=47 #将变量var值设置为47。在改变程序变量取值时，最好都使用set var格式的GDB命令。

自动化编译工具Makefile

make是个命令工具。

1

sudo apt install make #下载make命令

Makefile语法规则

一条规则：

1
2

目标：依赖文件列表
<Tab>命令列表

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

all:test1 test2
	echo "hello all"
	
test1:
	echo "hello test1"

test2:
	echo "hello test2"
#总共三条规则
#执行结果：make -f 1.mk
echo "hello test1"
hello test1
echo "hello test2"
hello test2
echo "hello all"
hello all

Makefile基本规则三要素：

目标:

​ 通常是要产生的文件名称，目标可以是可执行文件或其他obj文件，也可以是一个动作的名称。

依赖文件：

​ 用来输入从而产生目标的文件。

​ 一个目标通常有几个依赖文件（可以没有）

命令：

​ make执行的动作，一个规则可以含几个命令（可以没有）

​ 有多个命令，每个命令占一行。

make命令格式

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

make [-f file][options][targets]
[-f file]:
make默认在工作目录中寻找为GNUmakefile,makefile,Makefile的文件作为makefile输入文件。
-f可以指定以上名字以外的文件作为makefile输入文件。
[options]:
-v 显示make工具的版本
-w 在处理makefile之前和之后显示工作路径
-C dir 读取makefile之前改变工作路径至dir目录
-n 只打印要执行的命令但不执行
-s 执行但不显示执行的命令
[targets]:
若使用make命令时没有指定目标，则make工具默认会实现makefile文件内的第一个规则
指定了make工具要实现的目标，目标可以是一个或多个（多个目标用空格隔开）
make test1 -f 1.mk #就会执行目标为test1对应的语句。

Makefile示例

测试程序：test.c add.c sub.c mul.c div.c add.h sub.h mul.h div.h

1
2
3

#最简单的Makefile(首先vim Makefile)
test:test.c add.c sub.c mul.c div.c
	gcc test.c add.c sub.c mul.c div.c -o test

缺点：效率低，修改一个文件，所有文件都要重新编译。

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

test:test.o add.o sub.o mul.o div.o 
	gcc test.o add.o sub.o mul.o div.o -o test
add.o:add.c
	gcc -c add.c -o add.o
sub.o:sub.c
	gcc -c sub.c -o sub.o
mul.o:mul.c
	gcc -c mul.c -o mul.o
div.o:div.c
	gcc -c div.c -o div.o
test.o:test.c
	gcc -c test.c -o test.o

这样，下次编译，他只会编译你修改的文件，最后再链接，这样是比较高效的。

Makefile中的变量

在Makefile中使用变量有点类似c语言的宏定义，使用该变量相当于内容替换，使用变量可以使Makefile易于维护。如果.o文件很多，难道我们要一个一个打吗，这也未免太麻烦，还可能漏打。

自定义变量

定义变量：

1

变量名=变量值

引用变量：

1

$(变量名)或${变量名}

makefile的变量名：

makefile变量名可以以数字开头。

变量是大小写敏感的。

变量一般在makefile的头部定义

变量几乎可在makefile的任何地方使用

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

OBJS = test.o add.o sub.o mul.o div.o
test:$(OBJS)
	gcc $(OBJS) -o test
add.o:add.c
	gcc -c add.c -o add.o
sub.o:sub.c
	gcc -c sub.c -o sub.o
mul.o:mul.c
	gcc -c mul.c -o mul.o
div.o:div.c
	gcc -c div.c -o div.o
test.o:test.c
	gcc -c test.c -o test.o

除了使用用户自定义变量，makefile中也提供了一些变量（变量名大写）供用户使用，我们可以直接对其进行赋值。

1
2
3
4

CC=gcc
CPPFLAGS:
CFLAGS:
LDFLAGS:

自动变量

1
2
3
4

#这些变量不能单独使用 必须在命令中使用
# $@ 表示目标
# $^ 表示所有的依赖
# $< 表示第一个依赖

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

OBJS = test.o add.o sub.o mul.o div.o
TARGET=test
$(TARGET):$(OBJS)
	gcc $^ -o $@
add.o:add.c
	gcc -c $< -o $@
sub.o:sub.c
	gcc -c $< -o $@
mul.o:mul.c
	gcc -c $< -o $@
div.o:div.c
	gcc -c $< -o $@
test.o:test.c
	gcc -c $< -o $@

模式规则

1
2
3

#模式规则匹配示例
%.o:%.c
$(cc) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

1
2
3
4
5
6
7
8

OBJS=test.o add.o sub.o mul.o div.o
TARGET=test
$(TARGET):$(OBJS)
	gcc $(OBJS) -o $(TARGET)
#模式匹配 所有的.o都依赖对应的.c
#将所有的.c生成对应的.o
%.o:%.c
	gcc -c $< -o $@

Makefile的函数

常用的函数

1
2
3
4

wildcard #查找指定目录下的指定类型的文件
src=$(wildcard *.c) #找到当前目录下所有后缀为.c的文件，赋值给src
patsubst #匹配替换
obj=$(patsubst %.c,%.o,$(src)) #把src变量里所有后缀为.c的文件替换成.o

在makefile中所有的函数都是有返回值的。

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

#获取当前目录下所有的.c文件
SRC=$(wildcard ./*.c)
#将SRC中所有出现的.c的替换成.o
OBJS=$(patsubst %.c,%.o,$(SRC))
TARGET=test
$(TARGET):$(OBJS)
	gcc $(OBJS) -o $(TARGET)
#模式匹配 所有的.o都依赖对应的.c
#将所有的.c生成对应的.o
%.o:%.c
	gcc -c $< -o $@
#clean目标清除编译生成的中间文件
#执行命令 make clean
clean:
	rm -rf $(OBJS) $(TARGET)

Makefile中的伪目标

clean用途：清除编译生成的中间.o文件和最终目标文件

make clean 如果当前目录下有同名clean文件，则不执行clean对应的命令，解决方案：

伪目标声明：.PHONY:clean 声明目标为伪目标之后，makefile将不会判断目标是否存在或者该目标是否需要更新。

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

#获取当前目录下所有的.c文件
SRC=$(wildcard ./*.c)
#将SRC中所有出现的.c的替换成.o
OBJS=$(patsubst %.c,%.o,$(SRC))
TARGET=test
$(TARGET):$(OBJS)
	gcc $(OBJS) -o $(TARGET)
#模式匹配 所有的.o都依赖对应的.c
#将所有的.c生成对应的.o
%.o:%.c
	gcc -c $< -o $@
#clean目标清除编译生成的中间文件
#执行命令 make clean
#声明clean为伪目标
.PHONY:clean
clean:
	rm -rf $(OBJS) $(TARGET)

上面这个版本就是最终版。

1
2

@gcc -c $< -o $@ #在命令前加上@符号，表示不显示命令本身（默认显示），只显示结果
-gcc -c $< -o $@ #加上-符号，此条命令出错，make也会继续执行后续的命令。

系统调用

系统调用说的是操作系统提供给用户程序调用的一组”特殊”接口

系统调用和库函数的区别

Linux下对文件操作有两种方式：系统调用和库函数调用

库函数调用有两类函数组成：

不需要系统调用：不需要切换到内核空间即可完成函数全部功能，并且结果反馈给应用程序，如strcpy,bzero等字符串操作函数。

需要调用系统调用：需要切换到内核空间，这类函数通过封装系统调用去实现相应功能，如printf,fread等。

错误处理函数

errno是记录系统的最后一次错误代码，代码是一个int型的值，在errno.h中定义。查看错误代码errno是调试程序的一个重要方法。

当Linux C api函数出现异常时，一般会将errno全局变量赋一个整数值。

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

#include <stdio.h> //fopen
#include <errno.h> //errno
#include <string.h> //strerror(errno)
int main(){
    FILE *fp=fopen("xxxx","r");
    if(fp==NULL){
        printf("%d\n",errno);//打印错误码
        printf("%d\n",strerror(errno));//把errno的数字转换为相应的文字
        perror("fopen err"); //打印错误原因的字符串
        //perror和printf("%d\n",strerror(errno));实现效果相同。
    }
    return 0;
}

虚拟地址空间

每个进程都会分配虚拟地址空间，在32位机器上，该地址空间为4G。Linux每个运行的程序（进程），操作系统就会为其分配一个04G的地址空间（虚拟地址空间）。03G是用户区，3G~4G是内核区。在进程里平时所说的指针变量，保存的就是虚拟地址，当应用程序使用虚拟地址访问内存时，处理器会将其转换为物理地址（MMU）MMU将虚拟地址转换为物理地址。这样做的好处在于：进程隔离，更好的保护系统安全运行，屏蔽物理差异带来的麻烦，方便操作系统和编译器安排进程地址。

文件描述符

打开现存文件或新建文件时，系统内核会返回一个文件描述符，文件描述符用来指定已打开的的文件。这个文件描述符相当于已打开文件的标号，文件描述符是非负整数，是文件的标识，操作这个文件描述符相当于操作这个描述符所指定的文件。

程序运行起来后（每个进程）都有一张文件描述符的表，标准输入，标准输出，标准错误输出设备文件被打开，对应的文件描述符0，1，2记录在表中。程序运行起来后这三个文件描述符是默认打开的。

在程序运行起来后，打开其他文件时，系统会返回文件描述符表中最小可用的文件描述符，并将此文件描述符记录在表中。

最大打开的文件个数：

​ Linux中一个进程最多只能打开NR_OPEN_DEFAULT(即1024)个文件（当然这个数量的设定是可以修改的），故当文件不再使用时应该及时调用close()函数关闭文件。

常用文件IO函数

open函数

1
2
3
4
5

#include<sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname,int flags);
int open(const char *pathname,int flags,mode_t mode);

功能：

​ 打开文件，如果文件不存在则可以选择创建。

close函数

1
2
3

#include <unistd.h>

int close(int fd)

功能：

​ 关闭已打开的文件。

需要说明的是，当一个进程终止时，内核对该进程所有未关闭的文件描述符调用close关闭，所以即使用户程序不调用close,在终止时内核也会自动关闭它打开的文件。

但是对于一个常年累月的程序（比如网络服务器），打开的文件描述符一定要记得关闭，否则随着打开的文件越来越多，会占用大量的文件描述符和系统资源。

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

#include<stdio.h>
#include<string.h>
#include<sys/type.h>
#include<sys/stat.h>
#include<fcntl.h>
//打开和关闭文件
int main(){
    int fd=-1;
    //以只读的方式打开一个文件，如果文件不存在就报错。
    //fd=open("txt",O_RDONLY);
    //以只写的方式打开一个文件 如果文件存在就直接打开 如果文件不存在就新建一个文件。
    //fd=open("txt",O_WRONLY|O_CREAT,644);
    //以只写的方式打开一个文件，如果文件存在就报错，如果文件不存在就新建一个。
    //fd=open("txt",O_WRONLY|O_CREAT|O_EXCL,644);
    //以读写方式打开一个文件，如果文件存在就打开，如果文件不存在就新建一个文件。
    //fd=open("txt",O_RDWR|O_CREAT,644);
    //O_TRUNC 清空文件内容,如果文件存在，打开并清空，不存在就新建一个文件。
    //fd=open("txt",O_WRONLY|O_TRUNC|O_CREAT,644);
    //O_APPEND 追加的方式
    //以只写的方式和追加的方式打开一个文件 如果文件不存在会报错。
    fd=open("txt",O_WRONLY|O_APPEND)
    if(fd==-1){
        perror("open");
        return 1;
    }
    //关闭文件
    close(fd);
    return 0;
}

write函数

1
2
3
4
5
6
7
8
9
10
11

#include<unistd.h>
ssize_t write(int fd,const void* buf,size_t count);
功能：
    把指定数目的数据写到文件（fd）
参数：
    fd: 文件描述符
    buf:数据首地址
    count:写入数据的长度（字节）
返回值：
    成功：实际写入数据的字节个数
    失败：-1

read函数

1
2
3
4
5
6
7
8
9
10
11

#include<unistd.h>
ssize_t read(int fd,void *buf,size_t count);
功能：
    把指定数目的数据读到内存（缓冲区）
参数：
    fd:文件描述符
    buf:内存首地址
    count:读取的字节个数
返回值：
    成功：实际读取的字节个数
    失败：-1

阻塞和非阻塞的概念

读常规文件是不会阻塞，不管读多少字节，read一定会在有限的时间内返回。

从终端设备或网络则不一定，如果从终端输入的数据没有换行符，调用read读终端设备就会堵塞，如果网络上没有接受到数据包，调用read从网络读就会，至于会阻塞多久也是不确定的，如果没有一直收到数据到达就一直阻塞在那里。

同样，写常规文件是不会阻塞的，而向终端设备或网络写则不一定。

阻塞和非阻塞是对于文件而言，而不是指read,write等的属性。

lseek函数

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

#include<sys/types.h>
#include<unistd.h>
off_t lseek(int fd,off_t offset,int whence);
功能：
    改变文件的偏移量
参数：
    fd:文件描述符
    offset:根据whence来移动的位移数（偏移量），可以是正数，也可以是负数，如果正数，则相对于whence往右移动，如果是负数则相对于whence向左移动。如果向前移动的字节数超过了文件开头则出错返回，如果向后移动的字节数超过了文件末尾，再次写入时将增大文件尺寸。
    whence:其取值如下：
        SEEK_SET:从文件开头移动offset个字节
        SEEK_CUR:从当前位置移动offset个字节
        SEEK_END:从文件末尾移动offset个字节
返回值：
   	若lseek成功执行，则返回新的偏移量
    如果失败，返回-1

所有打开的文件都有一个当前文件偏移量（current file offset）以下简称为cfo。cfo通常是一个非负整数，用于表明文件开始处到文件当前位置的字节数。

读写操作通常开始cfo,并且使cfo变大，增量为读写的字节数。文件被打开时，cfo会被初始化为0，除非使用了O_APPEND。

如果把文件偏移量移到最后，使用read函数，将不会读出数据。要将文件描述符提前移到开头或者其他可以读到的位置。所以要注意文件描述符的位置。

文件操作相关函数

stat函数

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

#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>

int stat(const char* path,struct stat *buf);
int lstat(const char* pathname,struct stat *buf);
功能：
	获取文件状态信息
    stat和lstat的区别：
    	当文件是一个符号链接时,lstat返回的是该符号链接本身的信息；
    	而stat返回的是该链接指向的文件的信息。
参数：
    path:文件名
    buf:保存文件信息的结构体
返回值:
	成功：0
    失败：-1 文件不存在

stat函数和命令stat 文件名的功能类似。

struct stat *buf结构体

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

struct stat {
           dev_t      st_dev;      /* ID of device containing file */
           ino_t      st_ino;      /* Inode number */
           mode_t     st_mode;     /* File type and mode */
           nlink_t    st_nlink;    /* Number of hard links */
           uid_t      st_uid;      /* User ID of owner */
           gid_t      st_gid;      /* Group ID of owner */
           dev_t      st_rdev;     /* Device ID (if special file) */
           off_t      st_size;     /* Total size, in bytes */
           blksize_t  st_blksize;  /* Block size for filesystem I/O */
           blkcnt_t   st_blocks;   /* Number of 512 B blocks allocated */

           /* Since POSIX.1-2008, this structure supports nanosecond
              precision for the following timestamp fields.
              For the details before POSIX.1-2008, see VERSIONS. */
           struct timespec  st_atim;  /* Time of last access */
           struct timespec  st_mtim;  /* Time of last modification */
           struct timespec  st_ctim;  /* Time of last status change */

       #define st_atime  st_atim.tv_sec  /* Backward compatibility */
       #define st_mtime  st_mtim.tv_sec
       #define st_ctime  st_ctim.tv_sec
       };

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>

int main(void){
        int ret=-1;
        struct stat s;
        //获取指定文件信息
        ret=stat("txt",&s);
        if(ret==-1){
                perror("stat");
                return 1;
        }
        //文件属性信息
        printf("st_dev:%lu\n",s.st_dev);
        printf("st_ino:%ld\n",s.st_ino);
        return 0;
}

st_mode;可以获取文件类型和文件三种用户的权限。

access函数

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

#include<unistd.h>

int access(const char* pathname,int mode);
功能：测试指定文件是否具有某种属性
参数：
    pathname:文件名
    mode:文件权限，4种权限（判断文件所属者）
        R_OK:是否有读权限
        W_OK:是否有写权限
        X_OK:是否有执行权限
        F_OK:测试文件是否存在
返回值：
     0：有某种权限，或者文件存在
     -1：没有，或者文件不存在

chmod函数

1
2
3
4
5
6
7
8
9
10

#include <sys/stat.h>

int chmod(const char*pathname,mode_t mode);
功能：修改文件权限
参数：
    pathname:文件名
    mode:权限（8进制数）
返回值：
    成功：0
    失败：-1

chown函数

1
2
3
4
5
6
7
8
9
10
11

#include<unistd.h>

int chown(const char *pathname,uid_t owner,gid_t group);
功能：修改文件所有者和所属组
参数：
    pathname:文件或目录名
    owner:文件所有者id，通过查看/etc/passwd得到所有者id
    group；文件所属组id,通过查看/etc/group得到用户组id
返回值：
    成功：0
    失败：-1

truncate函数

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

#include<unistd.h>
#include<sys/types.h>

int truncate(const char *path,off_t length);
功能：修改文件大小
参数：
    path:文件名字
    length:指定的文件大小
        比原来小，删掉后边的部分
        比原来大，向后拓展
返回值：
    成功：0
    失败：-1

link函数

1
2
3
4
5
6
7
8
9

#include<unistd.h>
int link(const char* oldpath,const char *newpath);
功能：创建一个硬链接
参数：
    oldpath:源文件名字
    newpath:硬链接名字
返回值：
   	成功：0
    失败：-1

symlink函数

1
2
3
4
5
6
7
8
9
10

#include<unistd.h>

int symlink(const char* target,const char* linkpath);
功能：创建一个软链接
参数：
    target：源文件名字
    linKpath:软链接名字
返回值：
    成功：0
    失败：-1

剩下的还有readlink函数，unlink函数，rename函数

文件描述符复制

dup()和dup2()是两个非常有用的系统调用，都是用来复制一个文件的描述符，使新的文件描述符也标识旧的文件描述符所标识的文件

对比于dup(),dup2()也一样，通过原来的文件描述符复制出一个新的文件描述符，这样的话，原来的文件描述符和新的文件描述符都指向同一个文件，我们操作这两个文件描述符的任何一个，都能操作它所对应的文件。

dup函数

1
2
3
4
5
6
7
8
9
10

#include<unistd.h>

int dup(int oldfd);
功能：
    通过oldfd复制出一个新的文件描述符，新的文件描述符使调用进程文件描述符表中最小可用的文件描述符，最终oldfd和新的文件描述符都指向同一个文件。
参数：
    oldfd:需要复制的文件描述符oldfd
返回值：
    成功：新文件描述符
    失败：-1

函数示例：

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
//dup dup2
int main(){
        int fd=-1;
        int newfd=-1;
        //1.打开文件
        fd=open("txt",O_RDWR|O_CREAT,0644);
        if(fd==-1){
            perror("open");
            return 1;
        }
		newfd=dup(fd);
        if(-1==newfd){
             perror("dup");
             return 1;
        }
        printf("newfd=%d\n",newfd);
        //2.操作
        write(fd,"ABCDEFG",7);
        //因为这两个文件描述符共享一张文件表，所以当前文件的偏移量是共享的，所以下次不会覆盖而是追加
        //使用另外一个文件描述符
        write(newfd,"1234567",7);
        //3.关闭文件描述符
        close(fd);
        close(newfd);
        return 0;

}

dup2函数

1
2
3
4
5
6
7
8
9
10

#include<unistd.h>
int dup2(int oldfd,int newfd);
功能：
    通过oldfd复制出一个新的文件描述符newfd,如果成功，newfd和函数返回值是同一个返回值，最终oldfd和新的文件描述符newfd都指向同一个文件。
参数：
    oldfd:需要复制的文件描述符
    newfd:新的文件描述符，这个描述符可以人为指定一个合法数字（0-1023），如果指定的数字已经被占用，此函数会自动关闭close()断开这个数字和某个文件的关联，再来使用这个合法数字。
返回值：
    成功：返回newfd
    失败；返回-1。

注意：这里有个场景，我有两个程序都是要打开同一个文件并且向里面写东西，当然这就有两个open函数，那我先后打开该文件，前者写的会被后者写的覆盖掉吗，这是会的。因为每次open函数都会把文件偏移量的位置放回0。但是dup函数和dup2函数不会，因为复制的文件描述符共享一个文件描述符表项的。

fcntl函数

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

#include<unistd.h>
#include<fcntl.h>

int fcntl(int fd,int cmd,.../*arg */);
功能：改变已打开的文件性质，fcntl针对描述符提供控制。
参数：
    fd:操作的文件描述符
    cmd:操作方式
    arg:针对cmd的值，fcntl能够接受第三个参数int arg。
返回值：
    成功：返回某个其他值
    失败：-1

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
//fcntl复制文件描述符功能
int main(void){
    int fd=-1;
    int newfd=-1;
    int ret=-1;
    
    //1.打开文件
    fd=open("txt",O_WRONLY|O_CREAT,0644);
    if(fd==-1){
        perror("open");
        return 1;
    }
    printf("fd=%d\n",fd);
    //2.文件描述符复制
    //功能等价于dup函数
    //第三个参数0 表示返回一个最小的可用的文件描述符，并且大于或者等于0
    newfd=fcntl(fd,F_DUPFD,0);
    if(-1==newfd){
        perror("fcntl");
        return 1;
    }
    printf("newfd=%d\n",newfd);
    //3.写操作
    write(fd,"123456789",9);
    write(newfd,"ABCDEFGH",8);
    //4.关闭文件
    close(fd);
    close(newfd)
    return 0;
}

fcntl函数还可以改变文件状态标记。

目录相关操作

getcwd函数

1
2
3
4
5
6
7
8
9
10

#include<unistd.h>

char *getcwd(char *buf,size_t size);
功能：获取当前进程的工作目录
参数：
    buf:缓冲区，存储当前的工作目录
    size:缓冲区大小
返回值：
    成功：buf中保存当前进程工作目录位置
    失败：NULL

chdir函数

1
2
3
4
5
6
7
8
9

#include<unistd.h>

int chdir(const char *path);
功能：修改当前进程（应用程序）的路径
参数：
    path:切换的路径
返回值：
    成功：0
    失败：-1

opendir函数

1
2
3
4
5
6
7
8
9

#include<sys/types.h>
#include<dirent.h>
DIR *opendir(const char*name);
功能：打开一个目录
参数：
    name:目录名
返回值：
    成功：返回指向该目录结构体指针
    失败：NULL

closedir函数

1
2
3
4
5
6
7
8
9
10

#include<sys/types.h>
#include<dirent.h>

int closedir(DIR *dirp);
功能：关闭目录
参数：
    dirp:opendir返回指针
返回值：
    成功：0
    失败：-1

readdir函数

1
2
3
4
5
6
7
8

#include<dirent.h>
struct dirent* readdir(DIR *dirp);
功能：读取目录
参数：
    dirp:opendir的返回值
返回值：
    成功：目录结构体指针
    失败：NULL

readdir函数要读取目录所有内容是要循环读取。

进程控制

进程和程序

我们平时写的C语言代码，通过编译器编译，最终它会成为一个可执行程序，当这个可执行程序运行起来后（没有结束前），他就成为了一个进程。程序是存放在存储介质上的一个可执行文件，而进程是程序执行的过程。进程的状态是变化的，其包括进程的创建，调度和消亡。程序是静态的，进程是动态的。

在Linux系统中，操作系统是通过进程去完成一个一个的任务，进程是管理事务的基本单元。

进程拥有自己独立的处理环境（当前需要用到那些环境变量，程序运行的目录在哪里，当前是哪个用户在运行此程序）和系统资源（处理器cpu占用率，存储器，I/O设备，数据，程序）。

并行和并发

并行：指在同一时刻，有多条指令在多个处理器上同时执行。

并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

MMU

MMU是Memory Management Unit的缩写，中文名是内存管理单元，它是中央处理器（CPU）中用来管理虚拟存储器，物理存储器的控制线路，同时也负责虚拟地址映射为物理地址，以及提供硬件机制的内存访问授权，多用户多进程操作系统。

进程控制块PCB

进程运行时，内核为进程每个进程分配一个PCB(进程控制块)，维护进程相关的信息，Linux内核的进程控制块是task_struct结构体。

这个结构体的内部成员有很多，我们要知道的：

1. 进程id。系统中每个进程有唯一的id,在C语言中用pid_t类型表示，其实就是一个非负整数。
2. 进程的状态，有就绪，运行，挂起，停止等状态。
3. 进程切换时需要保存和恢复的一些CPU寄存器。
4. 描述虚拟地址空间的信息。
5. 描述控制终端的信息。
6. 当前工作目录。
7. umask掩码
8. 文件描述符表，包含很多指向file结构体的指针。
9. 和信号相关的信息。
10. 用户id和组id
11. 会话（Session）和进程组。
12. 进程可以使用的资源上限（Resource Limit）。

进程的状态

进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。

在三态模型中，进程状态分为三个基本状态，即运行态，就绪态，阻塞态。

在五态模型中，进程分为新建态，终止态，运行态，就绪态，阻塞态。

ps

进程是一个具有一定独立功能的程序，它是操作系统动态执行的基本单元。

ps命令可以查看进程的详细情况，常用选项（选项可以不加”-“）。

ps aux

ps ef和aux等价

ps -a

top

用来动态显示运行中的进程。

kill

kill命令指定进程号的进程，需要配合ps使用。

使用格式：

kill [-signal] pid

信号值从0-15，其中9为绝对终止，可以处理一般信号无法终止的进程。

有些进程不能直接杀死，这时候我们需要加一个参数”-9”,”-9”代表强制结束。

killall

通过进程名字杀死进程,进程名字是可以重复的。

1

killall -9 sleep

进程号和相关函数

每个进程都由一个进程号来标识，其类型为pid_t（整型），进程号的范围：0~32767（2的15次方-1）。进程号总是唯一的，但进程号可以重用。当一个进程终止后，其进程号就可以再次使用。

三个不同的进程号

进程号（PID）:

标识进程的一个非负整型数。

父进程号（PPID）:
任何进程（除init进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号成为父进程号（PPID）。如A进程创建了B进程，A的进程号就是B进程的父进程号。

进程组号（PGID）:

进程组是一个或多个进程的集合，他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID）。默认情况下，当前的进程号会当作当前的进程组号。

getpid函数

1
2
3
4
5
6
7
8

#include<sys/types.h>
#include<unistd.h>

pid_t getpid();
功能：
    获取本进程号（PID）
参数：无
返回值：本进程号

getppid函数

1
2
3
4
5
6
7
8

#include<sys/types.h>
#include<unistd.h>

pid_t getppid();
功能：获取调用此函数的进程的父进程号
参数：无
返回值：调用此函数的进程的父进程号（PPID）
    

getpgid函数

1
2
3
4
5
6
7
8
9

#include<sys/types.h>
#include<unistd.h>

pid_t getpgid(pid_t pid);
功能：获取进程组号（PGID）
参数：
    pid:进程号
返回值：
    参数为0时返回当前进程组号，否则返回参数指定的进程的进程组号。

进程的创建

系统允许一个进程创建新进程，新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。

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

#include<sys/types.h>
#include<unistd.h>

pid_t fork();
功能：
    用于从一个已存在的进程中创建一个新进程，新进程称为子进程，原进程称为父进程。
参数：无
返回值：
    成功：子进程返回0，父进程中返回子进程ID，pid_t为整型。
    失败：返回-1。
    失败的两个主要原因:
		1.当前的进程数已经达到系统规定的上限，这时errno的值被设置为EAGAIN。
        2.系统内存不足，这时errno的值被设置为ENOMEM。

使用示例：

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

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>

//创建一个子进程
int main()
{
    //创建子进程
    fork();
    
    printf("hello world\n");
    return 0;
}

这里的结果会输出两次hello world。这是为什么呢？

首先，fork函数创建子进程，子进程会将父进程的代码复制下来来执行了，当然这就有人说了，那么子进程执行fork函数，那就不是一直创建子进程了吗。这里涉及到了一个问题。当父进程调用fork函数，父进程会有一个pc指针指向fork函数调用后的代码，当然，子进程也把这个pc指针的值也继承了下来，所以子进程也是一样执行。

父子进程关系

使用fork函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间：包括进程上下文（进程执行活动全过程的的静态描述），进程堆栈，打开的文件描述符，信号控制设定，进程优先级，进程组号等。

子进程所独有的只有它的进程号，计时器等（只有小量信息）。因此，使用fork()函数的代价是很大的。

简单来说，一个进程调用fork函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值和原来的进程的值不同。相当于克隆了一个自己。

实际上，Linux的fork函数使用是通过写时拷贝（copy-on-write）实现。写时拷贝是一种可以推迟甚至避免拷贝数据的技术。内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。只用在需要写入的时候才会复制地址空间，从而使各个进程拥有各自的地址空间。也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。

fork之后父子进程共享文件，fork产生的子进程和父进程相同的文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。

区分父子进程

fork()函数被调用一次，但返回两次。两次返回的区别是：子进程的返回值是0，而父进程的返回值则是新子进程的进程ID。

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

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
//区分父子进程
int main(){
    pid_t pid=-1;
    //创建一个子进程
    //fork函数在在子进程中返回0 在父进程中返回子进程的pid
    pid=fork();
    if(pid==0){
        //子进程
        printf("hello pid:%d ppid:%d\n",getpid(),getppid());
        exit(0);
    }else{
        //父进程
       	//这里pid返回的就是新子进程的进程id
        printf("hello world pid:%d cpid:%d\n",getpid(),pid);
        
    }
    return 0;
}

父子进程堆空间

当在创建子进程前在堆声明时，一定要对该指针指向区域释放两次。不然会出现内存泄露。

如何检测内存是否泄露

1
2

gcc zfork.c
valgrind ./a.out

GDB调试多进程

使用GDB调试的时候，GDB只能跟踪一个进程。可以在fork函数调用之前，通过指令设置GDB调试工具跟踪父进程或者跟踪子进程。默认跟踪父进程。

1
2
3

set follow-fork-mode child #设置gdb在fork之后跟踪子进程
set follow-fork-mode parent #设置跟踪父进程（默认）
#注意，一定要在fork函数调用之前设置才有效。

进程退出函数

1
2
3
4
5
6
7
8
9
10
11

#include<stdlib.h>
void exit(int status);

#include<unistd.h>
void _exit(int status);
功能：
    结束调用此函数的进程
参数：
    status:返回给父进程的参数（低8位有效），至于这个参数是多少根据需要来填写。
返回值：
    无

exit()和_exit()函数功能和用法是一样的，无非是包含的头文件不一样，还有的区别就是：exit()属于标准库函数，_exit()属于系统调用函数。

_exit()函数不会关闭文件描述符和I刷新I/O缓冲区。exit()函数会做这些。

等待子进程退出函数

在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等。但是仍然为其保留一定的信息，这些信息主要指进程控制块PCB的信息（包括进程号，退出状态，运行时间）。

父进程可以调用wait或waitpid得到他的退出状态同时彻底清除掉这个进程。

wait()和waitpid函数的功能一样，区别在于wait()函数会堵塞，waitpid()可以设置不堵塞，waitpid()还可以指定等待那个子进程结束。

一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。

wait函数

1
2
3
4
5
6
7
8
9
10
11

#include<sys/types.h>
#include<sys/wait.h>

pid_t wait(int *status);
功能：
    等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收该子进程的资源。
参数：
    status:进程退出时的状态信息。
返回值：
    成功：已经结束子进程的进程号
    失败：-1

调用wait函数的进程会挂起（阻塞），直到它的一个子进程退出或收到一个不能被忽视的信号时才被唤醒（相当于继续往下执行）。

若调用进程没有子进程，该函数立即返回；若它的子进程已经结束，该函数同样会立即返回，并且会回收那个早已结束进程的资源。

所以wait函数的主要功能为回收已经结束子进程的资源。如果参数status的值不是NULL,wait函数就会把子进程退出时的状态取出并且存入其中，这是一个整数值（int）,指出了子进程是正常退出还是被非正常结束的。这个退出信息在一个int中包含了多个字段，直接使用这个值是没有意义的，我们需要宏定义取出其中的每个字段。

使用对应的宏函数如WIFEXITED(status)为非0表明进程正常结束。WEXITSTATUS(status)若WIFEXITED(status)值为真，获取进程退出状态（exit的参数）。

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

//属于正常退出
if(WIFEXITED(status)){
    printf("子进程退出状态码：%d\n",WEXITSTATUS(status));
}
else if(WIFSIGNALED(status)){
    //在bash输入kill 子进程号
    printf("子进程被信号%d杀死了\n",WTERMSIG(status));
}
else if(WIFSTOPPED(status)){
    //向指定进程发送暂停信号
    //kill -19 子进程号
    //唤醒指定暂停的进程
    //kill -18 子进程号
    printf("子进程被信号%d暂停\n",WSTOPSIG(status));
}

waitpid函数

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

#include<sys/types.h>
#include<sys/wait.h>
pid_t waitpid(pid_t pid,int *status,int options);
功能：
    等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。
参数：
    pid:参数pid的值有以下几种类型：
        pid>0 等待进程ID等于pid的子进程。
        pid=0 等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会等待他。
        pid=-1 等待任一子进程，此时waitpid和wait作用一样。
        pid<-1 等待指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。
    status:进程退出时的状态信息。和wait()用法一样。
    options:options提供了一些额外的选项来控制waitpid().
        0:同wait(),阻塞父进程，等待子进程退出。
        WNOHANG:没有任何已经结束的子进程，则立即返回
        WUNTRACED:如果子进程暂停了则此函数马上返回，并且不予理会子进程的结束状态。
返回值：
     当正常返回时，返回收集到的已经回收子进程的进程号
     如果设置了选项WNOHANG,而调用中waitpid()发现没有已经退出的子进程可等待，则返回0;
	 如果调用中出错，则返回-1，这是errno会被设置成相应的值以指示错误所在。

1
2
3
4

//等价于wait()
waitpid(-1,&status,0);
//第三个参数表示不阻塞
waitpid(-1,&status,WNOHANG)

孤儿进程

父进程运行结束，但子进程还在运行（未运行结束）的子进程就称为孤儿进程。

每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为init,而init进程会循环wait()它的已经退出的子进程。所以init进程会处理孤儿进程的善后工作。

孤儿进程并没有什么危害。

僵尸进程

进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸进程。这样就导致了一个问题，如果进程不调用wait()或者waitpid（）的话，那么保留的那段信息就不会释放，其进程号就会一直被占用。如果产生大量的僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程。

进程替换

在Windows平台下，我们可以通过双击运行可执行程序，让这个可执行程序成为一个进程；而在Linux平台，我们可以通过./运行，让一个可执行程序成为一个进程。

但是，如果我们本来就运行着一个程序，我们如何在这个进程内部启动一个外部程序，由内核将这个外部程序读入内存，使其执行起来成为一个进程呢，我们通过exec函数族实现。

exec函数族是一组函数，在Linux并不存在exec函数。这组函数一共有6个。

1
2
3
4
5
6
7
8
9
10
11

#include<unistd.h>
extern char **environ;


int execl(const char *path,const char *arg,.../*(char *) NULL*/);
int execlp(const char *file,const char *arg,.../*(char *) NULL*/);
int execle(const char *path,const char *arg,.../*,(char *) NULL,char * const envp[] */);
int execv(const char *path,char *const argv[]);
int execvp(const char *file,char *const argv[]);
int execvpe(const char *file,char *const argv[],char *const envp[]);
int execve(const char *filename,char *const argv[],char *const envp[]);

其中只有execve()是真正意义的系统调用，其他都是在此基础上经过包装的库函数。

exec函数族的作用是根据指定的文件名或目录名找到可执行文件，并用它来取代调用进程的内容。

进程在调用一种exec函数时，该进程完全由新程序替换，而新程序则从其main函数开始执行。因为调用exec并不创建新进程，所以前后进程ID(当然还有父进程号，进程组号，当前工作目录)并未改变。exec只是用另一个新程序替换了当前进程的正文，数据，堆和栈段（进程替换）。

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

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main(){
    printf("hello \n");
    //arg0 arg1 arg2 ... argn
    //arg0一般是可执行文件名 argn必须是NULL
    //execlp("ls","ls","-l","/home",NULL);
    //第一个参数是可执行文件的绝对路径或者相对路径
    //第二个参数一般是可执行文件的名字
    //中间的参数就是可执行文件的参数
    //最后一个参数是NULL
    execl("/bin/ls","ls","-l","/home",NULL);
    printf("hello world\n");
    return 0;
}

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

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#define _GNU_SOURCE
int main(){
    char *argv[]={"ls","-l","/home",NULL};
    char *envp[]={"ADDR=BEIJING",NULL};
    printf("hello\n");
    //第一个参数是可执行文件
    //第二个参数是指针数组 最后一定以NULL结束
    //execvp("ls",argv);
    //第一个参数是可执行文件
    //第二个参数是指针数组 最后一定以NULL结束
    //execv("/bin/ls",argv);
    //最后一个参数是环境变量指针数组
    //execle("/bin/ls","ls","-l","/home",NULL,envp);
    //第一个参数是可执行文件
    //第二个参数是参数列表 指针数组
    //第三个参数是环境变量列表 指针数组
    execvpe("ls",argv,envp);
    printf("hello world\n");
    return 0;
}

进程间通信

进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。

但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信。（IPC）

进程间通信的目的：

数据传输：一个进程需要将它的数据发送给另一个进程。

通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。

资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。

进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

Linux操作系统支持的主要进程间通信的通信机制：

无名管道

管道也叫无名管道，它是UNIX系统IPC(进程间通信)的最古老方式，所有的UNIX系统都支持这种通信机制。

管道有如下特点：

1. 半双工，数据在同一时刻只能在一个方向上流动。
2. 数据只能从管道的一端写入，从另一端读出。
3. 写入管道中的数据遵循先入先出的规则。
4. 管道所传送的数据是无格式的，这要求管道的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息。
5. 管道不是普通文件，不属于某个文件系统，其只存在于内存中。
6. 管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。
7. 从管道读数据是一次性操作，数据一旦被读走，他就从管道中被抛弃，释放空间以便写更多的数据。
8. 管道没有名字，只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。

管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。

pipe函数

1
2
3
4
5
6
7
8
9

#include<unistd.h>
int pipe(int pipefd[2]);
功能：创建无名管道
参数：
    pipefd:为int型数组的首地址，其存放了管道的文件描述符pipefd[0],pipefd[1]。
    当一个管道建立时，他会创建两个文件描述符fd[0]和fd[1]。其中fd[0]固定用于读管道，而fd[1]固定用于写管道。一般文件I/O的函数都可以用来操作管道（lseek()除外）。
返回值：
    成功：0
    失败：-1

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

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
//用于创建无名管道
int main(){
    int fd[2];
    int ret=-1;
    //创建一个无名管道
    ret=pipe(fd);
    if(ret==-1){
        perror("pipe");
        return 1;
    }
    //fd[0]用于读 fd[1]用于写
    printf("fd[0]:%d fd[1]:%d\n",fd[0],fd[1]);
    //关闭文件描述符
    close(fd[0]);
    close(fd[1]);
    return 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54