查man手册

man 1 xx查linux shell命令，man 2 xxx查API， man 3 xxx查库函数

文件平时是存在块设备中的文件系统中的，我们把这种文件叫静态文件。当我们去open打开一个文件时，linux内核做的操作包括：内核在进程中建立了一个打开文件的数据结构，记录下我们打开的这个文件；内核在内存中申请一段内存，并且将静态文件的内容从块设备中读取到内存中特定地址管理存放（叫动态文件）。

打开文件后，以后对这个文件的读写操作，都是针对内存中这一份动态文件的，而并不是针对静态文件的。当我们对动态文件进行读写后，此时内存中的动态文件和块设备中的静态文件就不同步了，当我们close关闭动态文件时，close内部内核将内存中的动态文件的内容去更新（同步）块设备中的静态文件。

文件描述符

(1)文件描述符其实实质是一个数字，这个数字在一个进程中表示一个特定的含义，当我们open打开一个文件时，操作系统在内存中构建了一些数据结构来表示这个动态文件，然后返回给应用程序一个数字作为文件描述符，这个数字就和我们内存中维护这个动态文件的这些数据结构挂钩绑定上了，以后我们应用程序如果要操作这一个动态文件，只需要用这个文件描述符进行区分。

(2)一句话讲清楚文件描述符：文件描述符就是用来区分一个程序打开的多个文件的。

(3)文件描述符的作用域就是当前进程，出了当前进程这个文件描述符就没有意义了。

O_TRUNC属性去打开文件时，如果这个文件中本来是有内容的，则原来的内容会被丢弃。
O_APPEND属性去打开文件时，如果这个文件中本来是有内容的，则新写入的内容会接续到原来内容的后面
如果O_APPEND和O_TRUNC同时出现，O_TRUNC生效。

O_CREAT，不管原来这个文件存在与否都能打开成功，如果原来这个文件不存在则创建一个空的新文件，如果原来这个文件存在则会重新创建这个文件，原来的内容会被消除掉
O_EXCL标志和O_CREAT标志来结合使用。则没有文件时创建文件，有这个文件时会报错提醒我们。

我们打开一个文件默认就是阻塞式的，如果你希望以非阻塞的方式打开文件，则flag中要加O_NONBLOCK标志。，只用于设备文件，而不用于普通文件。

无O_SYNC时write只是将内容写入底层缓冲区即可返回，然后底层（操作系统中负责实现open、write这些操作的那些代码，也包含OS中读写硬盘等底层硬件的代码）在合适的时候会将buf中的内容一次性的同步到硬盘中。这种设计是为了提升硬件操作的性能和销量，提升硬件寿命；但是有时候我们希望不等待，直接将我们的内容写入硬盘中，这时候就可以用O_SYNC标志。

正式终止进程（程序）应该使用exit或者_exit或者_Exit之一。

errno是由OS来维护的一个全局变量，任何OS内部函数都可以通过设置errno来告诉上层调用者究竟刚才发生了一个什么错误。

errno本身实质是一个int类型的数字，每个数字编号对应一种错误。当我们只看errno时只能得到一个错误编号数字（譬如-37），不适应于人看。

linux系统提供了一个函数perror（意思print error），perror函数内部会读取errno并且将这个不好认的数字直接给转成对应的错误信息字符串，然后print打印出来。

标准IO由一系列的C库函数构成（fopen、fclose、fwrite、fread），这些标准IO函数其实是由文件IO封装而来的。标准IO加了封装之后主要是为了在应用层添加一个缓冲机制，这样我们通过fwrite写入的内容不是直接进入内核中的buf，而是先进入应用层标准IO库自己维护的buf中，然后标准IO库自己根据操作系统单次write的最佳count来选择好的时机来完成write到内核中的buf（内核中的buf再根据硬盘的特性来选择好的实际去最终写入硬盘中）。

硬盘管理的时候是以文件为单位的，每个文件一个inode，每个inode有一个数字编号，对应一个结构体，结构体中记录了各种信息。
每个进程都有一个数据结构用来记录这个进程的所有信息（叫进程信息表），表中有一个指针会指向一个文件管理表，文件管理表中记录了当前进程打开的所有文件及其相关信息。文件管理表中用来索引各个打开的文件的index就是文件描述符fd，我们最终找到的就是一个已经被打开的文件的管理结构体vnode

一个vnode中就记录了一个被打开的文件的各种信息，而且我们只要知道这个文件的fd，就可以很容易的找到这个文件的vnode进而对这个文件进行各种操作。

所谓文件指针，就是我们文件管理表这个结构体里面的一个指针。所以文件指针其实是vnode中的一个元素。这个指针表示当前我们正在操作文件流的哪个位置。这个指针不能被直接访问，linux系统用lseek函数来访问这个文件指针。

计算文件长度

(1)linux中并没有一个函数可以直接返回一个文件的长度。但是我们做项目时经常会需要知道一个文件的长度，怎么办？自己利用lseek来写一个函数得到文件长度即可。
lseek(fd,0L,SEEK_END)
头文件

#include<sys/types.h>

#include<unistd.h>

定义函数

off_t lseek(int filde,off_t offset ,int whence);

SEEK_SET 将读写位置指向文件头后再增加offset个位移量。

SEEK_CUR 以目前的读写位置往后增加offset个位移量。

SEEK_END 将读写位置指向文件尾后再增加offset个位移量。

当whence 值为SEEK_CUR 或SEEK_END时，参数offet允许负值的出现。

(2)C语言stat()函数：获取文件状态

头文件：
#include <sys/stat.h> #include <unistd.h>

定义函数：
int stat(const char * file_name, struct stat *buf);

函数说明：
stat()用来将参数file_name 所指的文件状态, 复制到参数buf 所指的结构中。

#include <sys/stat.h>

#include <unistd.h>

main()

{

struct stat buf;

stat("/etc/passwd", &buf);

printf("/etc/passwd file size = %d \n", buf.st_size);

}

执行：

/etc/passwd file size = 705

(3)C语言fstat()函数：由文件描述词取得文件状态
fstat()与stat()作用完全相同, 不同处在于fstat()传入的参数为已打开的文件描述词.
#include <sys/stat.h>

#include <unistd.h>

#include <fcntk.h>

main()

{

struct stat buf;

int fd;

fd = open(“/etc/passwd”, O_RDONLY);

fstat(fd, &buf);

printf("/etc/passwd file size +%d\n ", buf.st_size);

}

执行：

/etc/passwd file size = 705

用lseek构建空洞文件

我们打开一个文件后，用lseek往后跳过一段，再write写入一段，就会构成一个空洞文件。

空洞文件方法对多线程共同操作文件是及其有用的。有时候我们创建一个很大的文件，如果从头开始依次构建时间很长。有一种思路就是将文件分为多段，然后多线程来操作每个线程负责其中一段的写入。

一个进程中两次打开同一个文件 结果是fd1和fd2分别读
说明：我们使用open两次打开同一个文件时，fd1和fd2所对应的文件指针是不同的2个独立的指针。文件指针是包含在动态文件的文件管理表中的，所以可以看出linux系统的进程中不同fd对应的是不同的独立的文件管理表。

一个进程中2个打开同一个文件，得到fd1和fd2.然后看是分别写还是接续写？
默认情况下应该是：分别写（实验验证过的）

有时候我们希望接续写而不是分别写？办法就是在open时加O_APPEND标志即可
O_APPEND的实现原理和其原子操作性说明

(1)O_APPEND为什么能够将分别写改为接续写？关键的核心是文件指针。分别写的内部原理就是2个fd拥有不同的文件指针，并且彼此只考虑自己的位移。但是O_APPEND标志可以让write和read函数内部多做一件事情，就是移动自己的文件指针的同时也去把别人的文件指针同时移动。（也就是说即使加了O_APPEND，fd1和fd2还是各自拥有一个独立的文件指针，但是这两个文件指针关联起来了，一个动了会通知另一个跟着动）

(2)O_APPEND对文件指针的影响，对文件的读写是原子的。
O_APPEND的含义是在每次写之前，都将标志位移动到文件的末端。表面上读这句话可能会有误解，提出一个问题：

当在O_APPEND打开后，然后用lseek移动到其他的位置，然后再用write写，这个时候，请问你数据写到哪里去了？是在末端，还是lseek移动到得位置。

答案是在末端，因为O_APPEND打开后，是一个原子操作：移动到末端，写数据。这是O_APPEND打开的作用。中间的插入时无效的。

例如 ：

int fd = open("test.txt",RDWR | O_APPEND);

lseek(fd,10,SEEK_SET);

if(write(fd,buffer,strlen(buffer)) !=strlen(buffer))

{

      perror("write error");

      exit(1);

}

 read(fd,buffer,20);

这里lseek是没有用的，write的写入是到末端的。在write写完后，标志位是在文件末端的，这个时候的读是不会读的，所以以前的lseek是没有用的，除非你读之前再lseek一次。

这里的read讲不会读出 任何数据，因为在末尾。它还是保持原来的写入的数据。

文件共享就是同一个文件（同一个文件指的是同一个inode，同一个pathname）被多个独立的读写体（几乎可以理解为多个文件描述符）去同时操作（一个打开尚未关闭的同时另一个去操作）。
常见的有3种文件共享的情况：第一种是同一个进程中多次使用open打开同一个文件，第二种是在不同进程中去分别使用open打开同一个文件（这时候因为两个fd在不同的进程中，所以两个fd的数字可以相同也可以不同），第三种情况是linux系统提供了dup和dup2两个API来让进程复制文件描述符。

文件描述符的本质是一个数字，这个数字本质上是进程表中文件描述符表的一个表项，进程通过文件描述符作为index去索引查表得到文件表指针，再间接访问得到这个文件对应的文件表。
当我们去open时，内核会从文件描述符表中挑选一个最小的未被使用的数字给我们返回。也就是说如果之前fd已经占满了0-9，那么我们下次open得到的一定是10.（但是如果上一个fd得到的是9，下一个不一定是10，这是因为可能前面更小的一个fd已经被close释放掉了）
fd中0、1、2已经默认被系统占用了，因此用户进程得到的最小的fd就是3了。

linux内核占用了0、1、2这三个fd是有用的，当我们运行一个程序得到一个进程时，内部就默认已经打开了3个文件，这三个文件对应的fd就是0、1、2。这三个文件分别叫stdin、stdout、stderr。也就是标准输入、标准输出、标准错误。

标准输入一般对应的是键盘（可以理解为：0这个fd对应的是键盘的设备文件），标准输出一般是LCD显示器（可以理解为：1对应LCD的设备文件）

printf函数其实就是默认输出到标准输出stdout上了。stdio中还有一个函数叫fpirntf，这个函数就可以指定输出到哪个文件描述符中。

使用dup进行文件描述符复制

(1)dup系统调用对fd进行复制，会返回一个新的文件描述符（譬如原来的fd是3，返回的就是4）

(2)dup系统调用有一个特点，就是自己不能指定复制后得到的fd的数字是多少，而是由操作系统内部自动分配的，分配的原则遵守fd分配的原则。

(3)dup返回的fd和原来的oldfd都指向oldfd打开的那个动态文件，操作这两个fd实际操作的都是oldfd打开的那个文件。实际上构成了文件共享。

我们可以close(1)关闭标准输出，关闭后我们printf输出到标准输出的内容就看不到了

然后我们可以使用dup重新分配得到1这个fd，这时候就把oldfd打开的这个文件和我们1这个标准输出通道给绑定起来了。这就叫标准输出的重定位。

dup2和dup的作用是一样的，都是复制一个新的文件描述符。但是dup2允许用户指定新的文件描述符的数字。
dup2复制的文件描述符，和原来的文件描述符虽然数字不一样，但是这两个指向同一个打开的文件

交叉写入的时候，结果是接续写（实验证明的）

命令行中重定位命令 >
这个>的实现原理，其实就是利用open+close+dup，open打开一个文件2.txt，然后close关闭stdout，然后dup将1和2.txt文件关联起来即可。

fcntl函数是一个多功能文件管理的工具箱，接收2个参数+1个变参。第一个参数是fd表示要操作哪个文件，第二个参数是cmd表示要进行哪个命令操作。变参是用来传递参数的，要配合cmd来使用。

linux中各种文件类型
普通文件（- regular file）
目录文件（d directory）
字符设备文件（c character）
块设备文件（b block）
管道文件（p pipe）
套接字文件（s socket）
符号链接文件（l link）

常用文件属性获取
stat、fstat、lstat函数简介
fstat和stat的区别是：stat是从文件名出发得到文件属性信息结构体，而fstat是从一个已经打开的文件fd出发得到一个文件的属性信息。
lstat和stat/fstat的差别在于：对于符号链接文件，stat和fstat查阅的是符号链接文件指向的文件的属性，而lstat查阅的是符号链接文件本身的属性。

linux命令行下还可以去用stat命令去查看文件属性信息，实际上stat命令内部就是使用stat系统调用来实现的。

文件属性中的文件类型标志在struct stat结构体的mode_t st_mode元素中，这个元素其实是一个按位来定义的一个位标志（有点类似于ARM CPU的CPSR寄存器的模式位定义）。这个东西有很多个标志位共同构成，记录了很多信息，如果要查找时按位&操作就知道结果了，但是因为这些位定义不容易记住，因此linux系统给大家事先定义好了很多宏来进行相应操作。

譬如S_ISREG宏返回值是1表示这个文件是一个普通文件，如果文件不是普通文件则返回值是0.

st_mode中除了记录了文件类型之外，还记录了一个重要信息：文件权限。

linux并没有给文件权限测试提供宏操作，而只是提供了位掩码，所以我们只能用位掩码来自己判断是否具有相应权限。

ls -l打印出的权限列表
（第一位是文件类型）（后9位是权限描述）

(1)123456789一共9位，3个一组。第一组三个表示文件的属主（owner、user）对该文件的可读、可写、可执行权限；第2组3个位表示文件的属主所在的组（group）对该文件的权限；第3组3个位表示其他用户（others）对该文件的权限。

(2)属主就是这个文件属于谁，一般来说文件创建时属主就是创建这个文件的那个用户。但是我们一个文件创建之后还可以用chown命令去修改一个文件的属主，还可以用chgrp命令去修改一个文件所在的组。

access函数可以测试得到当前执行程序的那个用户在当前那个环境下对目标文件是否具有某种操作权限。

chmod/fchmod与权限修改

(1)chmod是一个linux命令，用来修改文件的各种权限属性。chmod命令只有root用户才有权利去执行修改。

(2)chmod命令其实内部是用linux的一个叫chmod的API实现的。

umask与文件权限掩码

(1)文件掩码是linux系统中维护的一个全局设置，umask的作用是用来设定我们系统中新创建的文件的默认权限的。

(2)umask命令就是用umask API实现的

读取目录文件

opendir与readdir函数

(1)opendir打开一个目录后得到一个DIR类型的指针给readdir使用

(2)readdir函数调用一次就会返回一个struct dirent类型的指针，这个指针指向一个结构体变量，这个结构体变量里面记录了一个目录项（所谓目录项就是目录中的一个子文件）。

(3)readdir调用一次只能读出一个目录项，要想读出目录中所有的目录项必须多次调用readdir函数。readdir函数内部户记住哪个目录项已经被读过了哪个还没读，所以多次调用后不会重复返回已经返回过的目录项。当readdir函数返回NULL时就表示目录中所有的目录项已经读完了。

linux系统中的时间

jiffies的引入

(1)jiffies是linux内核中的一个全局变量，这个变量用来记录以内核的节拍时间为单位时间长度的一个数值。

(2)内核配置的时候定义了一个节拍时间，实际上linux内核的调度系统工作时就是以这个节拍时间为时间片的。

(3)jiffies变量开机时有一个基准值，然后内核每过一个节拍时间jiffies就会加1，然后到了系统的任意一个时间我们当前时间就被jiffies这个变量所标注。

内核在开机启动的时候会读取RTC硬件获取一个时间作为初始基准时间，这个基准时间对应一个jiffies值（这个基准时间换算成jiffies值的方法是：用这个时间减去1970-01-01 00:00:00 +0000(UTC)，然后把这个时间段换算成jiffies数值），这个jiffies值作为我们开机时的基准jiffies值存在。然后系统运行时每个时钟节拍的末尾都会给jiffies这个全局变量加1，因此操作系统就使用jiffies这个全局变量记录了下来当前的时间。当我们需要当前时间点时，就用jiffies这个时间点去计算（计算方法就是先把这个jiffies值对应的时间段算出来，然后加上1970-01-01 00:00:00 +0000(UTC)即可得到这个时间点）

(2)其实操作系统只在开机时读一次RTC，整个系统运行过程中RTC是无作用的。RTC的真正作用其实是在OS的2次开机之间进行时间的保存。

常用的时间相关的API和C库函数有9个：time/ctime/localtime/gmtime/mktime/asctime/strftime/gettimeofday/settimeofday

linux中随机数相关API

(1)连续多次调用rand函数可以返回一个伪随机数序列

(2)srand函数用来设置rand获取的伪随机序列的种子.

(1)在每次执行程序时，先用srand设置一个不同的种子，然后再多次调用rand获取一个伪随机序列，这样就可以每次都得到一个不同的伪随机序列。

(2)一般常规做法是用time函数的返回值来做srand的参数。

proc文件系统的思路是：在内核中构建一个虚拟文件系统/proc，内核运行时将内核中一些关键的数据结构以文件的方式呈现在/proc目录中的一些特定文件中，这样相当于将不可见的内核中的数据结构以可视化的方式呈现给内核的开发者。

proc目录下的文件大小都是0，因为这些文件本身并不存在于硬盘中，他也不是一个真实文件，他只是一个接口，当我们去读取这个文件时，其实内核并不是去硬盘上找这个文件，而是映射为内核内部一个数据结构被读取并且格式化成字符串返回给我们。所以尽管我们看到的还是一个文件内容字符串，和普通文件一样的；但是实际上我们知道这个内容是实时的从内核中数据结构来的，而不是硬盘中来的。

常用proc中的文件介绍

(1)/proc/cmdline

(2)/proc/cpuinfo

(3)/proc/devices

(4)/proc/interrupts

proc文件系统的使用

1.cat以手工查看

2.程序中可以文件IO访问

3.在shell程序中用cat命令结合正则表达式来获取并处理内核信息

4.扩展：sys文件系统

(1)sys文件系统本质上和proc文件系统是一样的，都是虚拟文件系统，都在根目录下有个目录（一个是/proc目录，另一个是/sys目录），因此都不是硬盘中的文件，都是内核中的数据结构的可视化接口。

(2)不同的是/proc中的文件只能读，但是/sys中的文件可以读写。读/sys中的文件就是获取内核中数据结构的值，而写入/sys中的文件就是设置内核中的数据结构的元素的值。

.程序的开始和结束

main函数由谁调用

(1)编译链接时的引导代码。操作系统下的应用程序其实在main执行前也需要先执行一段引导代码才能去执行main，我们写应用程序时不用考虑引导代码的问题，编译连接时（准确说是连接时）由链接器将编译器中事先准备好的引导代码给连接进去和我们的应用程序一起构成最终的可执行程序。

(2)运行时的加载器。加载器是操作系统中的程序，当我们去执行一个程序时（譬如./a.out，譬如代码中用exec族函数来运行）加载器负责将这个程序加载到内存中去执行这个程序。

(3)程序在编译连接时用链接器，运行时用加载器，这两个东西对程序运行原理非常重要。

(4)argc和argv的传参如何实现

程序如何结束

(1)正常终止：return、exit、_exit

(2)非正常终止：自己或他人发信号终止进程

atexit注册进程终止处理函数

(1)进程被正常终止时，系统会自动调用被注册的函数。

(2)atexit注册多个进程终止处理函数，先注册的后执行（先进后出，和栈一样）

(2)return、exit和_exit的区别：return和exit效果一样，都是会执行进程终止处理函数，但是用_exit终止进程时并不执行atexit注册的进程终止处理函数。

进程环境

环境变量

(1)export命令查看环境变量

(2)进程环境表介绍.每一个进程中都有一份所有环境变量构成的一个表格，也就是说我们当前进程中可以直接使用这些环境变量。进程环境表其实是一个字符串数组，用environ变量指向它。

(3)程序中通过environ全局变量使用环境变量

(4)我们写的程序中可以无条件直接使用系统中的环境变量，所以一旦程序中用到了环境变量那么程序就和操作系统环境有关了。

(5)获取指定环境变量函数getenv

#include <stdio.h>
int main(void)
{
    extern char **environ;      // 声明就能用
    int i = 0;
    
    while (NULL != environ[i])
    {
        printf(“%s\n”, environ[i]);
        i++;
    }
    return 0;
}

进程运行的虚拟地址空间

(1)操作系统中每个进程在独立地址空间中运行

(2)每个进程的逻辑地址空间均为4GB（32位系统）

(3)0-1G为OS，1-4G为应用

(4)虚拟地址到物理地址空间的映射

(5)意义。进程隔离，提供多进程同时运行

进程的正式引入

什么是进程

(1)动态过程而不是静态实物

(2)进程就是程序的一次运行过程，一个静态的可执行程序a.out的一次运行过程（./a.out去运行到结束）就是一个进程。

(3)进程控制块PCB（process control block），内核中专门用来管理一个进程的数据结构。

进程ID

(1)getpid（当前进程id）、getppid（获取父进程id）、getuid（获取当前进程的用户id）、geteuid（有效用户id）、getgid(组id）、getegid（有效组id）

(2)实际用户ID和有效用户ID区别（可百度）

多进程调度原理

(1)操作系统同时运行多个进程

(2)宏观上的并行和微观上的串行

(3)实际上现代操作系统最小的调度单元是线程而不是进程

fork函数调用一次会返回2次，返回值等于0的就是子进程，而返回值大于0的就是父进程。

典型的使用fork的方法：使用fork后然后用if判断返回值，并且返回值大于0时就是父进程，等于0时就是子进程。

fork的返回值在子进程中等于0，在父进程中等于本次fork创建的子进程的进程ID。

子进程继承父进程中打开的文件

(1)上下文：父进程先open打开一个文件得到fd，然后在fork创建子进程。之后在父子进程中各自write向fd中写入内容

(2)测试结论是：接续写。实际上本质原因是父子进程之间的fd对应的文件指针是彼此关联的（很像O_APPEND标志后的样子）

实际测试时有时候会看到只有一个，有点像分别写。但是实际不是，原因是（某个先运行完毕的进程，会close掉fd文件，导致后运行的进程无法写入）

父子进程各自独立打开同一文件实现共享

(1)父进程open打开1.txt然后写入，子进程打开1.txt然后写入，结论是：分别写。原因是父子进程分离后才各自打开的1.txt，这时候这两个进程的PCB已经独立了，文件表也独立了，因此2次读写是完全独立的。

(2)open时使用O_APPEND标志看看会如何？实际测试结果标明O_APPEND标志可以把父子进程各自独立打开的fd的文件指针给关联起来，实现接续写。

linux系统设计时规定：每一个进程退出时，操作系统会自动回收这个进程涉及到的所有的资源（譬如malloc申请的内容没有free时，当前进程结束时这个内存会被释放，譬如open打开的文件没有close的在程序终止时也会被关闭）。但是操作系统只是回收了这个进程工作时消耗的内存和IO，而并没有回收这个进程本身占用的内存（8KB，主要是task_struct和栈内存）

因为进程本身的8KB内存操作系统不能回收需要别人来辅助回收，因此我们每个进程都需要一个帮助它收尸的人，这个人就是这个进程的父进程。

僵尸进程

(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”，在这一段（子进程已经结束且父进程尚未帮其收尸）子进程就被成为僵尸进程。

(2)子进程除task_struct和栈外其余内存空间皆已清理

(3)父进程可以使用wait或waitpid以显式回收子进程的剩余待回收内存资源并且获取子进程退出状态。

(4)父进程也可以不使用wait或者waitpid回收子进程，此时父进程结束时一样会回收子进程的剩余待回收内存资源。（这样设计是为了防止父进程忘记显式调用wait/waitpid来回收子进程从而造成内存泄漏）

孤儿进程

(1)父进程先于子进程结束，子进程成为一个孤儿进程。

(2)linux系统规定：所有的孤儿进程都自动成为一个特殊进程（进程1，也就是init进程）的子进程。

父进程wait回收子进程

wait的工作原理

(1)子进程结束时，系统向其父进程发送SIGCHILD信号

(2)父进程调用wait函数后阻塞

(3)父进程被SIGCHILD信号唤醒然后去回收僵尸子进程

(4)父子进程之间是异步的，SIGCHILD信号机制就是为了解决父子进程之间的异步通信问题，让父进程可以及时的去回收僵尸子进程。

(5)若父进程没有任何子进程则wait返回错误
wait的参数status。status用来返回子进程结束时的状态，父进程通过wait得到status后就可以知道子进程的一些结束状态信息。

wait的返回值pid_t，这个返回值就是本次wait回收的子进程的PID。当前进程有可能有多个子进程，wait函数阻塞直到其中一个子进程结束wait就会返回，wait的返回值就可以用来判断到底是哪一个子进程本次被回收了。

对wait做个总结：wait主要是用来回收子进程资源，回收同时还可以得知被回收子进程的pid和退出状态。

WIFEXITED、WIFSIGNALED、WEXITSTATUS这几个宏用来获取子进程的退出状态。

WIFEXITED宏用来判断子进程是否正常终止（return、exit、_exit退出）

WIFSIGNALED宏用来判断子进程是否非正常终止（被信号所终止）

WEXITSTATUS宏用来得到正常终止情况下的进程返回值的。

printf(“子进程已经被回收，子进程pid = %d.\n”, ret);
printf(“子进程是否正常退出：%d\n”, WIFEXITED(status));
printf(“子进程是否非正常退出：%d\n”, WIFSIGNALED(status));
printf(“正常终止的终止值是：%d.\n”, WEXITSTATUS(status));

waitpid介绍

waitpid和wait差别

(1)基本功能一样，都是用来回收子进程

(2)waitpid可以回收指定PID的子进程

(3)waitpid可以阻塞式或非阻塞式两种工作模式

代码实例

(1)使用waitpid实现wait的效果

ret = waitpid(-1, &status, 0); -1表示不等待某个特定PID的子进程而是回收任意一个子进程，0表示用默认的方式（阻塞式）来进行等待，返回值ret是本次回收的子进程的PID

(2)ret = waitpid(pid, &status, 0); 等待回收PID为pid的这个子进程，如果当前进程并没有一个ID号为pid的子进程，则返回值为-1；如果成功回收了pid这个子进程则返回值为回收的进程的PID

(3)ret = waitpid(pid, &status, WNOHANG);这种表示父进程要非阻塞式的回收子进程。此时如果父进程执行waitpid时子进程已经先结束等待回收则waitpid直接回收成功，返回值是回收的子进程的PID；如果父进程waitpid时子进程尚未结束则父进程立刻返回（非阻塞），但是返回值为0（表示回收不成功）。

exec族函数可以直接把一个编译好的可执行程序直接加载运行
exec族的6个函数介绍

(1)execl和execv

这两个函数是最基本的exec，都可以用来执行一个程序，区别是传参的格式不同。execl是把参数列表（本质上是多个字符串，必须以NULL结尾）依次排列而成（l其实就是list的缩写），execv是把参数列表事先放入一个字符串数组中，再把这个字符串数组传给execv函数。

(2)execlp和execvp

这两个函数在上面2个基础上加了p，较上面2个来说，区别是：上面2个执行程序时必须指定可执行程序的全路径（如果exec没有找到path这个文件则直接报错），而加了p的传递的可以是file（也可以是path，只不过兼容了file。加了p的这两个函数会首先去找file，如果找到则执行执行，如果没找到则会去环境变量PATH所指定的目录下去找，如果找到则执行如果没找到则报错）

(3)execle和execvpe

这两个函数较基本exec来说加了e，函数的参数列表中也多了一个字符串数组envp形参，e就是environment环境变量的意思，和基本版本的exec的区别就是：执行可执行程序时会多传一个环境变量的字符串数组给待执行的程序。

(1)main函数的原型其实不止是int main(int argc, char **argv)，而可以是

int main(int argc, char **argv, char **env) 第三个参数是一个字符串数组，内容是环境变量。

(2)如果用户在执行这个程序时没有传递第三个参数，则程序会自动从父进程继承一份环境变量（默认的，最早来源于OS中的环境变量）；如果我们exec的时候使用execlp或者execvpe去给传一个envp数组，则程序中的实际环境变量是我们传递的这一份（取代了默认的从父进程继承来的那一份）

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>  
#include <sys/wait.h>
#include <stdlib.h>
int main(void)
{
    pid_t pid = -1;
    pid_t ret = -1;
    int status = -1;
    
    pid = fork();
    if (pid > 0)
    {
        // 父进程
        printf(“parent, 子进程id = %d.\n”, pid);
    }
    else if (pid == 0)
    {
        // 子进程
        //execl(“/bin/ls”, “ls”, “-l”, “-a”, NULL);     // ls -l -a
        //char * const arg[] = {“ls”, “-l”, “-a”, NULL};
        //execv(“/bin/ls”, arg);
        
        //execl(“hello”, “aaa”, “bbb”, NULL);
        //char * const arg[] = {“aaa”, “bbb”, NULL};
        //execv(“hello”, arg);
        
        //execlp(“ls”, “ls”, “-l”, “-a”, NULL); 
        char * const envp[] = {“AA=aaaa”, “XX=abcd”, NULL};
        execle(“hello”, “hello”, “-l”, “-a”, NULL, envp);
        
        return 0;
    }
    else
    {
        perror(“fork”);
        return -1;
    }
    
    return 0;
}

进程的5种状态

(1)就绪态。这个进程当前所有运行条件就绪，只要得到了CPU时间就能直接运行。

(2)运行态。就绪态时得到了CPU就进入运行态开始运行。

(3)僵尸态。进程已经结束但是父进程还没来得及回收

(4)等待态（浅度睡眠&深度睡眠），进程在等待某种条件，条件成熟后可进入就绪态。等待态下就算你给他CPU调度进程也无法执行。浅度睡眠等待时进程可以被（信号）唤醒，而深度睡眠等待时不能被唤醒只能等待的条件到了才能结束睡眠状态。

(5)暂停态。暂停并不是进程的终止，只是被被人（信号）暂停了，还可以恢复的。

system函数基本 = fork+exec，但它的操作是原子的

进程关系

(1)无关系

(2)父子进程关系

(3)进程组（group）由若干进程构成一个进程组

(4)会话（session）会话就是进程组的组

进程查看命令 ps

(1)ps -ajx 偏向显示各种有关的ID号

(2)ps -aux 偏向显示进程各种占用资源

向进程发送信号指令 kill

(1)kill -信号编号 进程ID，向一个进程发送一个信号

守护进程

(1)daemon，表示守护进程，简称为d（进程名后面特意带d的基本就是守护进程）

(2)长期运行（一般是开机运行直到关机时关闭）

(3)与控制台脱离（普通进程都和运行该进程的控制台相绑定，表现为如果终端被强制关闭了则这个终端中运行的所有进程都被会关闭，背后的问题还在于会话）

(4)服务器（Server），服务器程序就是一个一直在运行的程序，可以给我们提供某种服务（譬如nfs服务器给我们提供nfs通信方式），当我们程序需要这种服务时我们可以调用服务器程序（和服务器程序通信以得到服务器程序的帮助）来进程这种服务操作。服务器程序一般都实现为守护进程。

常见守护进程

(1)syslogd，系统日志守护进程，提供syslog功能。

(2)cron，cron进程用来实现操作系统的时间管理，linux中实现定时执行程序的功能就要用到cron。

编写简单守护进程

任何一个进程都可以将自己实现成守护进程

create_daemon函数要素

(1)fork一个子进程并让父进程直接退出

(2)子进程使用setsid创建新的会话期，脱离控制台

(3)调用chdir将当前工作目录设置为‘/’

(4)umask设置为0以取消任何文件权限屏蔽（确保该进程创建的文件可以被别的进程操作）

(5)关闭所有文件描述符（使用sysconf（int name）函数获取当前操作系统的允许的最大文件描述符，然后使用for循环，从0，关闭到最大的）

(6)将0、1、2定位到/dev/null（直接运行三次open，打开/dev/null文件，即可）

使用syslog来记录调试信息

openlog、syslog、closelog

(1)一般log信息都在操作系统的/var/log/messages这个文件中存储着，但是ubuntu中是在/var/log/syslog文件中的。

syslog的工作原理

(1)操作系统中有一个守护进程syslogd（开机运行，关机时才结束），这个守护进程syslogd负责进行日志文件的写入和维护。

(2)syslogd是独立于我们任意一个进程而运行的。我们当前进程和syslogd进程本来是没有任何关系的，但是我们当前进程可以通过调用openlog打开一个和syslogd相连接的通道，然后通过syslog向syslogd发消息，然后由syslogd来将其写入到日志文件系统中。

(3)syslogd其实就是一个日志文件系统的服务器进程，提供日志服务。任何需要写日志的进程都可以通过openlog/syslog/closelog这三个函数来利用syslogd提供的日志服务。这就是操作系统的服务式的设计。

#include <stdio.h>
#include <syslog.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
    printf(“my pid = %d.\n”, getpid());
    
    
    openlog(“b.out”, LOG_PID | LOG_CONS, LOG_USER);
    
    syslog(LOG_INFO, “this is my log info.%d”, 23);
    syslog(LOG_INFO, “this is another log info.”);
    syslog(LOG_INFO, “this is 3th log info.”);
    
    closelog();
}

让程序不能被多次运行实现方法：

(1)最常用的一种方法就是：用一个文件的存在与否来做标志。具体做法是程序在执行之初去判断一个特定的文件是否存在，若存在则标明进程已经在运行，若不存在则标明进程没有在运行。然后运行程序时去创建这个文件。当程序结束的时候去删除这个文件即可。

(2)这个特定文件要古怪一点，确保不会凑巧真的在电脑中存在的。

.linux的进程间通信概述

(2)同一个进程在一个地址空间中，所以同一个进程的不同模块（不同函数、不同文件）之间都是很简单的（很多时候都是全局变量、也可以通过函数形参实参传递）

(3)2个不同的进程处于不同的地址空间，因此要互相通信很难。

(3)结论：IPC技术在一般中小型程序中用不到，在大型程序中才会用到。

linux内核提供多种进程间通信机制

(1)无名管道和有名管道

(2)SystemV IPC：信号量、消息队列、共享内存

(3)Socket域套接字

(4)信号

linux的IPC机制1-管道

管道（无名管道）

(1)管道通信的原理：内核维护的一块内存，有读端和写端（管道是单向通信的）

(2)管道通信的方法：父进程创建管道后fork子进程，子进程继承父进程的管道fd

(3)管道通信的限制：只能在父子进程间通信、半双工

(4)管道通信的函数：pipe、write、read、close

有名管道（fifo）

(1)有名管道的原理：实质也是内核维护的一块内存，表现形式为一个有名字的文件

(2)有名管道的使用方法：固定一个文件名，2个进程分别使用mkfifo创建fifo文件，然后分别open打开获取到fd，然后一个读一个写

(3)管道通信限制：半双工（注意不限父子进程，任意2个进程都可）

(4)管道通信的函数：mkfifo、open、write、read、close

SystemV IPC介绍

SystemV IPC的基本特点

(1)系统通过一些专用API来提供SystemV IPC功能

(2)分为：信号量、消息队列、共享内存

(3)其实质也是内核提供的公共内存

消息队列

(1)本质上是一个队列，队列可以理解为（内核维护的一个）FIFO

(2)工作时A和B2个进程进行通信，A向队列中放入消息，B从队列中读出消息。

信号量

(1)实质就是个计数器（其实就是一个可以用来计数的变量，可以理解为int a）

(2)通过计数值来提供互斥和同步

共享内存

(1)大片内存直接映射

(2)类似于LCD显示时的显存用法

剩余的2类IPC

(1)信号

(2)Unix域套接字 socket

什么是信号

信号是内容受限的一种异步通信机制

(1)信号的目的：用来通信

(2)信号是异步的（对比硬件中断）

(3)信号本质上是int型数字编号（事先定义好的）

信号由谁发出

(1)由操作系统内核发出信号

(2)其他进程发出信号

(3)进程内部也会发出信号，如alarm闹钟时间到会产生SIGALARM信号，向一个读端已经关闭的管道write时会产生SIGPIPE信号

信号由谁处理、如何处理

(1)忽略信号

(2)捕获信号（信号绑定了一个函数）

(3)默认处理（当前进程没有明显的处理这个信号，默认：忽略或终止进程）

常见信号介绍

(1)SIGINT 2 Ctrl+C时OS送给前台进程组中每个进程

(2)SIGABRT 6 调用abort函数，进程异常终止

(3)SIGPOLL SIGIO 8 指示一个异步IO事件，在高级IO中提及

(4)SIGKILL 9 杀死进程的终极办法

(5)SIGSEGV 11 无效存储访问时OS发出该信号

(6)SIGPIPE 13 涉及管道和socket

(7)SIGALARM 14 涉及alarm函数的实现

(8)SIGTERM 15 kill命令发送的OS默认终止信号

(9)SIGCHLD 17 子进程终止或停止时OS向其父进程发此信号

(10)SIGUSR1 10 用户自定义信号，作用和意义由应用自己定义

(11)SIGUSR2 12 用户自定义信号，作用和意义由应用自己定义

进程对信号的处理

用signal函数处理SIGINT信号

(1)默认处理

(2)忽略处理

(3)捕获处理

细节：

(1)signal函数绑定一个捕获函数后信号发生后会自动执行绑定的捕获函数，并且把信号编号作为传参传给捕获函数

(2)signal的返回值在出错时为SIG_ERR，绑定成功时返回旧的捕获函数

signal函数的优点和缺点

(1)优点：简单好用，捕获信号常用

(2)缺点：无法简单直接得知之前设置的对信号的处理方法

sigaction函数介绍

(1)2个都是API，但是sigaction比signal更具有可移植性

(2)用法关键是2个sigaction指针

sigaction比signal好的一点：sigaction可以一次得到设置新捕获函数和获取旧的捕获函数（其实还可以单独设置新的捕获或者单独只获取旧的捕获函数），而signal函数不能单独获取旧的捕获函数而必须在设置新的捕获函数的同时才获取旧的捕获函数。

alarm和pause函数

alarm函数

(1)内核以API形式提供的闹钟，闹钟时间到了之后，所在线程会得到一个SIGALRM信号
内核给每个进程仅仅提供一个alarm时钟，多次调用会刷新闹钟，而不会创建多个闹钟（需要多个定时器，可以使用posix定时器）

pause函数

(1)内核挂起

pause函数的作用就是让当前进程暂停运行，交出CPU给其他进程去执行。当当前进程进入pause状态后当前进程会表现为“卡住、阻塞住”，要退出pause状态当前进程需要被信号唤醒。

使用alarm和pause可以来模拟sleep

非阻塞式IO
如何实现非阻塞IO访问：O_NONBLOCK和fcntl函数，fcntl函数可以设置已经打开文件的标志，为其添加非阻塞标志。

IO多路复用
select和poll
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
int main(void)
{
    // 读取鼠标
    int fd = -1, ret = -1;
    char buf[200];
    fd_set myset;
    struct timeval tm;
    
    fd = open(“/dev/input/mouse1”, O_RDONLY);
    if (fd < 0)
    {
        perror(“open:”);
        return -1;
    }
    
    // 当前有2个fd，一共是fd一个是0
    // 处理myset
    FD_ZERO(&myset);
    FD_SET(fd, &myset);
    FD_SET(0, &myset);
    
    tm.tv_sec = 10;
    tm.tv_usec = 0;
    ret = select(fd+1, &myset, NULL, NULL, &tm);
    if (ret < 0)
    {
        perror("select: ");
        return -1;
    }
    else if (ret == 0)
    {
        printf(“超时了\n”);
    }
    else
    {
        // 等到了一路IO，然后去监测到底是哪个IO到了，处理之
        if (FD_ISSET(0, &myset))
        {
            // 这里处理键盘
            memset(buf, 0, sizeof(buf));
            read(0, buf, 5);
            printf(“键盘读出的内容是：[%s].\n”, buf);
        }
        
        if (FD_ISSET(fd, &myset))
        {
            // 这里处理鼠标
            memset(buf, 0, sizeof(buf));
            read(fd, buf, 50);
            printf(“鼠标读出的内容是：[%s].\n”, buf);
        }
    }
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <poll.h>
int main(void)
{
    // 读取鼠标
    int fd = -1, ret = -1;
    char buf[200];
    struct pollfd myfds[2] = {0};
    
    fd = open(“/dev/input/mouse1”, O_RDONLY);
    if (fd < 0)
    {
        perror(“open:”);
        return -1;
    }
    
    // 初始化我们的pollfd
    myfds[0].fd = 0;            // 键盘
    myfds[0].events = POLLIN;   // 等待读操作
    
    myfds[1].fd = fd;           // 鼠标
    myfds[1].events = POLLIN;   // 等待读操作
    ret = poll(myfds, fd+1, 10000);
    if (ret < 0)
    {
        perror("poll: ");
        return -1;
    }
    else if (ret == 0)
    {
        printf(“超时了\n”);
    }
    else
    {
        // 等到了一路IO，然后去监测到底是哪个IO到了，处理之
        if (myfds[0].events == myfds[0].revents)
        {
            // 这里处理键盘
            memset(buf, 0, sizeof(buf));
            read(0, buf, 5);
            printf(“键盘读出的内容是：[%s].\n”, buf);
        }
        
        if (myfds[1].events == myfds[1].revents)
        {
            // 这里处理鼠标
            memset(buf, 0, sizeof(buf));
            read(fd, buf, 50);
            printf(“鼠标读出的内容是：[%s].\n”, buf);
        }
    }
    return 0;
}

异步IO

(1)几乎可以认为：异步IO就是操作系统用软件实现的一套中断响应系统。

(2)异步IO的工作方法是：我们当前进程注册一个异步IO事件（使用signal注册一个信号SIGIO的处理函数），然后当前进程可以正常处理自己的事情，当异步事件发生后当前进程会收到一个SIGIO信号从而执行绑定的处理函数去处理这个异步事件。

涉及的函数：

(1)fcntl（F_GETFL、F_SETFL、F_SETOWN、O_ASYNC）

(2)signal或者sigaction（SIGIO）

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
int mousefd = -1;
// 绑定到SIGIO信号，在函数内处理异步通知事件
void func(int sig)
{
    char buf[200] = {0};
    
    if (sig != SIGIO)
        return;
    read(mousefd, buf, 50);
    printf(“鼠标读出的内容是：[%s].\n”, buf);
}
int main(void)
{
    // 读取鼠标
    char buf[200];
    int flag = -1;
    
    mousefd = open(“/dev/input/mouse1”, O_RDONLY);
    if (mousefd < 0)
    {
        perror(“open:”);
        return -1;
    }   
    // 把鼠标的文件描述符设置为可以接受异步IO
    flag = fcntl(mousefd, F_GETFL);
    flag |= O_ASYNC;
    fcntl(mousefd, F_SETFL, flag);
    // 把异步IO事件的接收进程设置为当前进程
    fcntl(mousefd, F_SETOWN, getpid());
    
    // 注册当前进程的SIGIO信号捕获函数
    signal(SIGIO, func);
    
    // 读键盘
    while (1)
    {
        memset(buf, 0, sizeof(buf));
        //printf(“before 键盘 read.\n”);
        read(0, buf, 5);
        printf(“键盘读出的内容是：[%s].\n”, buf);
    }
        
    return 0;
}

存储映射IO

mmap函数

LCD显示和IPC之共享内存

存储映射IO的特点

(1)共享而不是复制，减少内存操作

(2)处理大文件时效率高，小文件不划算

每个线程都有自己独立的栈

线程常见函数

线程创建与回收

(1)pthread_create 主线程用来创造子线程的

(2)pthread_join 主线程用来等待（阻塞）回收子线程

(3)pthread_detach 主线程用来分离子线程，分离后主线程不必再去回收子线程

线程取消

(1)pthread_cancel 一般都是主线程调用该函数去取消（让它赶紧死）子线程

(2)pthread_setcancelstate 子线程设置自己是否允许被取消

(3)pthread_setcanceltype
PTHREAD_CANCEL_DEFERRED 等待到达取消点再取消线程
PTHREAD_CANCEL_ASYNCHRONOUS 直接取消线程

线程函数退出相关

(1)pthread_exit与return退出

(2)pthread_cleanup_push

(3)pthread_cleanup_pop

获取线程id

(1)pthread_self

网络地址决定了这种网络中一定可以有多少个网络，譬如子网掩码为255.255.255.0时表示我们这一种网络一共最多可以有2^{24个，每个这种网络中可以有2}8个主机。

如果子网掩码为255.255.0.0时，表示我们这种网络可以有2^{16个网络，每个这种网络中最多可以有2}16个主机。

192.168.1.102 & 255.255.255.0 = 192.168.1.0

192.168.1.253 & 255.255.255.0 = 192.168.1.0

192.168.1.4和192.168.12.5，如果子网掩码是255.255.255.0那么不在同一网段，如果子网掩码是255.255.0.0那么就在同一个网段

socket编程接口介绍

建立连接

(1)socket。socket函数类似于open，用来打开一个网络连接，如果成功则返回一个网络文件描述符（int类型），之后我们操作这个网络连接都通过这个网络文件描述符。

(2)bind

(3)listen

(4)connect

发送和接收

(1)send和write

(2)recv和read

辅助性函数（IP地址在点分十进制和32位16进制数之间的转换）

(1)inet_aton、inet_addr、inet_ntoa（不支持IPv6）

(2)inet_ntop、inet_pton（支持IPv6）

表示IP地址相关数据结构

(1)都定义在 netinet/in.h

(2)struct sockaddr，这个结构体是网络编程接口中用来表示一个IP地址的，注意这个IP地址是不区分IPv4和IPv6的（或者说是兼容IPv4和IPv6的）

(3)typedef uint32_t in_addr_t; 网络内部用来表示IP地址的类型

(4)struct in_addr

{

in_addr_t s_addr;

};

(5)struct sockaddr_in

{

__SOCKADDR_COMMON (sin_);

in_port_t sin_port;                 /* Port number.  */

struct in_addr sin_addr;            /* Internet address.  */



/* Pad to size of `struct sockaddr'.  */

unsigned char sin_zero[sizeof (struct sockaddr) -

                       __SOCKADDR_COMMON_SIZE -

                       sizeof (in_port_t) -

                       sizeof (struct in_addr)];

};

(6)struct sockaddr 这个结构体是linux的网络编程接口中用来表示IP地址的标准结构体，bind、connect等函数中都需要这个结构体，这个结构体是兼容IPV4和IPV6的。在实际编程中这个结构体会被一个struct sockaddr_in或者一个struct sockaddr_in6所填充。

服务器端程序编写

(1)socket

(2)bind

(3)listen

(4)accept，返回值是一个fd，accept正确返回就表示我们已经和前来连接我的客户端之间建立了一个TCP连接了，以后我们就要通过这个连接来和客户端进行读写操作，读写操作就需要一个fd，这个fd就由accept来返回了。

注意：socket返回的fd叫做监听fd，是用来监听客户端的，不能用来和任何客户端进行读写；accept返回的fd叫做连接fd，用来和连接那端的客户端程序进行读写。

客户端程序编写

(1)socket

(2)connect

概念：端口号，实质就是一个数字编号，用来在我们一台主机中（主机的操作系统中）唯一的标识一个能上网的进程。端口号和IP地址一起会被打包到当前进程发出或者接收到的每一个数据包中。每一个数据包将来在网络上传递的时候，内部都包含了发送方和接收方的信息（就是IP地址和端口号），所以IP地址和端口号这两个往往是打包在一起不分家的。