Linux文件/IO,应用编程

左手的ㄟ右手 2022-06-12 00:45 170阅读 0赞

`-----------------------应用框架结构------------------------------`

`• 应用编程框架介绍`

`信号：`

`多线程：（多核心CPU）`

`-----------------------------------------------------------------------`

`------------------------------------------------------------------------------------`

`• 文件操作的一些系统API`

`什么是操作系统API?：`

`API其实就是一些函数，APP通过操作系统提供的API来使用硬件干活，而硬件如何干活，则就是驱动程序的工作了。`

`Linux一些常用的文件IO接口：`

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    /************************
     *OPEN_API函数的FLAG测试*
     ************************/
    int main(int argc, const char *argv[])
    { 
     int fd = -1;
     int ret = -1;
     char read_buf[100] = {0};
     char write_buf[100] = "my_loveianidn\nsaindisnafhabfa";
     
     //第一步：打开文件 
     //int open(const char *pathname, int flags); 返回一个文件描述符
     fd = open("test.txt", O_RDWR | O_APPEND | O_EXCL | O_CREAT, 0666);
     
     if (-1 == fd)
     { 
     //printf("打开失败.\n");
     perror("打开失败");
     _exit(-1);
     }
     else
     { 
     printf("打开成功,成功打开的文件操作符为[%d].\n", fd);
     }
     
    #if 0
     //第二步：读取文件
     //ssize_t read(int fd, void *buf, size_t count);
     ret = read(fd, read_buf, 20);
     if(-1 == ret)
     { 
     //printf("读取失败.\n");
     perror("读取失败");
     _exit(-1);
     }
     else
     { 
     printf("读取成功，成功读取的大小为：[%d].\n", ret);
     printf("读取的内容为：[%s].\n", read_buf);
     }
    #endif
    
    #if 1
     //第三步：写入文件
     //ssize_t write(int fd, const void *buf, size_t count)
     ret = write(fd, write_buf, strlen(write_buf));
     if(-1 == ret)
     { 
     //printf("写入失败.\n");
     perror("写入失败");
     _exit(-1);
     } 
     else
     { 
     printf("写入成功，成功写入了[%d]字节.\n", ret);
     }
    #endif
     
     //第四步：关闭文件
     close(fd);
     return 0;
    }

open,read,write,close

Iseek,改变文件指针

操作文件的一般步骤：

（1）静态文件（2）动态文件

文件都是存放在块设备中的（INAND,SD）这些文件称为静态文件，当需要操作文件的时间，利用API（OPEN）来打开文件，此时操作系统采取的措施是，先将这个文件加载到内存中，然后给这个文件它的数据结构（方便读写），然后进行读写。这段在内存中的文件就是动态文件，当我们更改结束时，需要用CLOSE，将它加载同步回静态文件，所以这也是为什么不保存就不会发生改变的原因。

为什么要这样设计？

也许你要问为什么不直接在硬盘上进行操作呢？这是由于硬盘的一些特性决定的，我们知道硬盘的特点是容量大，但是操作不灵活，而内存（RAM）的特性，可以随机访问，且速度快，所以这样设计。

重要概念：文件描述符

文件描述符其实就是一个数字，用来表示区分，打开的文件在当前进程中的。他的生命周期就是当前进程。当你打开同时打开3个进程，操作系统怎么知道你需要操作的是哪个文件呢？文件描述符就是对这些打开的文件进行编号区分，便于操作。

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• 一个文件读写的实例

fd->文件描述符

（1）open函数返回的是fd ，其余函数返回的是另外的ret，且参数O\_RDWR(现在还不明白为什么这样)

（2）read函数返回的是ret，当成功时返回一个成功读取的字节数，当失败时，返回一个-1.

（3）write函数返回的是ret，当成功时返回一个成功读取的字节数，当失败时，返回一个-1.

（4）close函数返回的ret,一般不会出错，所以没加以判断，但应该判断，这是好习惯。

它的传参是fd.

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• open的flag详解

O\_TRUNC：

加了这个flag，则若读取，就会置空本次读取的文件。

O\_APPEND：

加了这个flag，若写入，则会在源文件后面，添加上本次写入的信息。

O\_CREAT:

打开文件有一个问题，如果不存在这个文件，那么调用open打开，会报错。但有时间我们就需要向VIM直接打开并创建一个文件，用O\_CREAT flag即可。

O\_EXCL:

以上，万一创建的时间有一个文件和名字一样，那么现在再创建的时间会覆盖掉源文件，会产生恶劣影响，我们又需要像windowS那样的提示，不让我们创建，那么就需要 O\_EXCL和O\_CREAT合作使用了。

O\_SYNC：

——阻塞式与非阻塞式：

当函数需要某项功能，它开始调用一些功能（比如蜂鸣器），然后这个时间有许多的程序都在调用这个功能，它有两个选择

（1）原地等待，指导前面的程序跑完，然后它开始使用蜂鸣器。（阻塞式）

（2）先遛了，然后待会没有人使用的时间在回来（非阻塞式）

异同：

阻塞式明显有个好处，那就是它一定可以结束完成后，再返回，所以它返回的结果是一定成功的。

非阻塞式，它不能带回一个确切的结果，但是它节约了时间。

O\_NONBLOCK

![Image 1][]特性：![SouthEast][]

很多时间我们需要调用系统的硬件驱动，而对硬件的操作的程序一般都是存放在缓冲区中的，因为频繁的操作硬件，会减少硬件的寿命。所以，这里的程序都是阻塞式的，但是有些时间，我们迫切需要使用到这个硬件，那么就需要O\_NONBLOCK，来告知硬件系统，现在就开始使用硬件。

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• 文件读写的一些细节

errno（错误信息编码）

perror（打印错误信息）

查询man手册确定该函数是否带errno

(主要查看RETURN　ＶＡＬＵＥ)

![SouthEast 1][]

write 和 read 的conut 和阻塞式

write 和 read 的conut我们在读取或者写入时是无法确切知道的，因为我们也不知道需要写入或者读写到底多大，这里牵扯出一个问题

文件里有20b的内容，而我们read打开时，需要读取的内容是30b,这里正好是阻塞式的，然后程序就会在原地等待剩下的10b，这样其实没有必要，且效率很低。

![SouthEast 2][]

所以系统把文件IO封装成标准IO (fOPEN)

用标准IO操作文件，然后存在标准IO的BUF中，然后等待一个合适的大小，一起存入操作系统内的buf中。这样就大大提高了效率。

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• Linux系统如何管理文件

硬盘中的静态文件和inode（i节点）

通过之前的学习我们知道什么是静态文件，也就是存放在硬盘中的文件，那么，一般都是怎么读取这些文件的呢？静态文件的管理分为两个部分

（1）硬盘中的管理项

管理项就相当于索引点，系统通过这些索引，来找到相关文件的内容（inode），其实就是一个对应数据结构的结构体，它里面存放着一些文件的信息，当需要哪个文件的时间，我们就通过检索这个结构体，与需要的文件相匹配，由此找到文件。

（2）硬盘中的存储项

这个就不说了，就是一个一个的块设备，来存储信息的。

特性：格式化U盘，有两种办法

（1）：快速格式化，这个格式化速度很快，其实就是只删除了文件管理项。也就是索引。所以已经删除的信息是可以找回的。

（2）：低级格式化，这个格式化速度很慢（亲测），这个才是彻底删除信息，也就是将信息从内存中抹去。

内存中的V节点（vnode）

我们知道文件分为动态和静态的，所以这里的操作都是在内存中，自然就是动态的。当某个进程需要某个文件，则将它从硬盘中将它的文件管理项读出，并且利用进程管理，去管理它，此时进程会建立一个v节点，也就是这个文件的数据结构，一个V节点中存放了这个文件的fd，以及各种信息，所以就可以对这个文件进行各种操作了。

文件与流的概念：

流：（stream）其实编写的程序，比如，续接两个字符串，我们就是通过循环，对一个一个的字符进行操作对比，以及拼接。文件也是如此，文件的操作不可能是一块一块的，其实归根结底也是一个一个的字符进行操作。对一个一个字符的读写，也就是形成了流的概念。

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• lseek详解

（1）文件指针

RDWR隐式的更改文件指针，lSEEK显示的更改文件指针。一开始打开文件时，都是默认到文件开头的，RD,WR都是向后偏移一个。

lSEEK，是指定文件指针的偏移量；

off\_t lseek(int fd, off\_t offset, int whence);

SEEK\_SET 从文件头

SEEK\_CUR 从文件中

SEEK\_END 从文件尾

（1）利用lseek计算文件大小

lseek(fd, 0 SEEK\_END)直接把文件指针移动到文件尾所的到的偏移量就是文件大小。

（2）利用lseek构造空洞文件

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    /************************
     * 计算文件大小小程序 *
     ************************/
     //iseek：移动文件指针到文件头，文件中，文件尾，返回移动的偏移量，可以利用这个特性计算文件大小
    int cal_lenFun(const char *pathname);
    int main(int argc, const char *argv[])
    { 
     if (argc != 2)
     { 
     printf("—————————————————————————————————————————————\n");
     printf("请正确输入，请在程序后加索要计算的文件名.\n");
     printf("譬如:");
     printf("%s pathname.\n", argv[0]);
     printf("—————————————————————————————————————————————\n");
     _exit(-1);
     }
     
     
     printf("文件的大小为：%d.\n", cal_lenFun(argv[1]));
     
     return 0;
    }
    
    int cal_lenFun(const char *pathname)
    { 
     int ret = -1;
     int fd = -1;
     //打开文件
     //int open(const char *pathname, int flags, mode_t mode);
     fd = open(pathname, O_RDWR | O_CREAT, 0666);
     if (-1 == fd)
     { 
     perror("打开错误");
     return -1;
     }
     
     //计算长度
     //off_t lseek(int fd, off_t offset, int whence);
     ret = lseek(fd, 0, SEEK_END);
     if (-1 == ret)
     { 
     perror("lseek error");
     return -1;
     }
     
     
     return ret;
     
    }

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• 打开多个文件（文件共享）

两个文件指针（两种情况）

1.读取

![SouthEast 3][]

（1）分别读取

（2）续借读取

同时打开两个文件进行读写

对两个文件进行读取，如图所示，文件指针是由不同进程的文件管理表管理的，所以拥有两个不同的文件指针。所以是分别读取的。

2.写入

那么在写入的时间，由于是两个分离的文件指针，所以当fd1写入后，fd2写入则会覆盖掉原来的文件。

O\_APPEND标志：

加了这个标志就可以解决覆盖的问题。

原子特性：

O\_APPEND实现的原理就是原子特性的，原子特性就是当一个进程开始工作以后，除非到它结束，否则就不能停止。

（1）同一个进程多次OPEN文件

![SouthEast 4][]

（2）多个进程分别OPEN文件

![SouthEast 5][]

\_\_\_\_\_dup系统：

dup和重定位:

dup系统调用，就是重新复制一个fd，之前发现，打开文件后fd总是从3开始，那么012去哪里呢？

0-----stdin

1-----stdout

2-----stderr

所以当我们close(1)然后再用dup去复制一个fd那么系统就会自动分配fd = 1给我们用，这时间,我们再往输出上的信息就会重定位到我们当前fd=1的文件里了。

(tips)fd的管理其实是一个数组。所以数值上是连续的切不可跳跃的。

\_\_\_\_\_dup2系统：

dup2可以指定一个确切的fd，函数原型如下。

int dup2(int oldfd, int newfd);

所以便可以轻松实现上面的输出重定位。

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• FCNTL接口

int fcntl(int fd, int cmd, ... /\* arg \*/ );

可以实现仿制dum2,dum2的缺点在于需要指定一个Fd，而万一你指定的这个fd正好在被使用，那么就会产生错误，而fcntl则不会产生这种问题，他会分配一个最靠近且不在占用的Fd给你。

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    /************************
     * fcntl函数的使用
     ************************/
    //利用fcntl拷贝一个文件描述符，比较安全
    #define FILENAME "1.txt"
    int main(int argc, const char *argv[])
    { 
     //打开文件
     int fd1 = -1;
     int fd2 = -1;
     fd1 = open(FILENAME, O_RDWR | O_CREAT | O_TRUNC, 0666);
     if (-1 == fd1)
     { 
     perror("open");
     _exit(-1);
     }
     printf("成功打开文件fd1:%d.\n", fd1);
     //close(1); //关闭1 然后复制一个fd，则会分配1
     fd2 = fcntl(fd1, F_DUPFD, 1); 
     //(fd, 指令flag, 预计得到的fd,如果占用就选择一个没被使用的，而且是最接近的)
     if (-1 == fd1)
     { 
     perror("fcntl");
     _exit(-1);
     }
     printf("11111.\n");
     printf("成功打开文件fd2:%d.\n", fd2);
     
    #if 0
     while(1)
     { 
     write(fd1, "aa", 2);
     sleep(1);
     write(fd2, "cc", 2);
     }
    #endif
     
     return 0;
    }

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• 标准输入输出

Fopen Fclose Fwrite Fread Ffulsh Fseek

Fread r+

Fwrite w+

在fclose后一定要将fp指针归0.

fp = NULL;

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    #define FILENAME "1.txt"
    /************************
     * 标准输入输出 *
     ************************/
    int main(int argc, const char *argv[])
    { 
     FILE *fp = NULL;
     char read_buf[100] = {0};
     size_t len = 0;
    #if 0
     //FILE *fopen(const char *path, const char *mode);
     //打开(目的读取)文件
     fp = fopen(FILENAME, "r+");
     if (NULL == fp)
     { 
     perror("Fopen");
     _exit(-1);
     }
     printf("成功打开文件fp:%p\n", fp);
     
     //读取文件
     //size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
     memset(read_buf, 0, sizeof(read_buf));
     len = fread(read_buf, sizeof(read_buf[0]), 
     sizeof(read_buf)/sizeof(read_buf[0]), fp);
     printf("fread is [%s].\n", read_buf);
     printf("lenoffile:[%d].\n", len*sizeof(read_buf[0]));
    #endif
     //FILE *fopen(const char *path, const char *mode);
     //打开(目的读取)文件
     fp = fopen(FILENAME, "w+");
     char write_buf[10] = "CCAAADWe";
     int ret = -1;
     if (NULL == fp)
     { 
     perror("Fopen");
     _exit(-1);
     }
     printf("成功打开文件fp:%p\n", fp);
     //写入文件
     //size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream);
     len = fwrite(write_buf, 1, 10, fp);
     if (-1 == len)
     { 
     perror("fwrite");
     _exit(-1);
     }
     printf("lenoffile:[%d].\n", len);
     ret = fclose(fp);
     if(0 == ret)
     printf("okokok.\n");
     fp = NULL;
     printf("fp=%p.\n", fp);
     return 0;
    }

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• 文件属性

文件属性的获取

int stat(const char \*path, struct stat \*buf);

int fstat(int fd, struct stat \*buf);

int lstat(const char \*path, struct stat \*buf);

stat是获取从一个路径获取文件属性，所以是从硬盘里读取

Fstas是从fd获取，所以是从内存中获取，是从已打开文件中获取，所以速度会快写。

lstat是获取文件权限，区别于上面两个的是，上面两个获取的文件属性如果是链接文件，则会自动追踪到源文件，而Lstat则不会追踪，它获取的就是当前文件的属性。

一些宏和St\_mode

![Image 1][]

如果测试权限是如上可读的那么就是返回1，利用了这样一个位与的操作

文件权限不是谁创建的它而是谁运行的它

第一组是属主，第二组是属主所在的组，第三组是其他

指令：

(vvvvvvvvip)\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

权限测试API ——————access

当前用户对于测试文件的权限。

修改权限API—————— chomd

chown root filename修改文件的属主

chgrp root filename文件所在的组

umask 0000为补

读取目录文件API—————— opendir 、readdir

重入版本

具体使用请看代码。

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• 关于时间的概念

GMT时间：格林尼治时间

UTC时间：原子钟时间

点时间：具体某点的时间（RTC）

段时间：点时间 -点时间（定时器）

电脑在开机时会去读取一个RTC,然后根据系统的节拍，给jiffies加数，算出一个距离1970的时间节点的秒数、

•API实战：

time :获取计算机元年到现在的一共的秒数

ctime:通过time获取的秒数，的到一个字符型的时间

gmtime:UTC时间

localtime:当地时间

asctime:和ctime一样

strftime:用户定义时间格式

•随机数

随机数API rand

srand(time(NULL));设置随机数种子

rand()%n0~n-1 的随机数

linux内核中产生一个半真正意义上的随机数种子，依靠一些随机产生的动作，比如，用户操作鼠标，键盘等，依靠这些作为随机数种子，即可产生一个意义上的随机数。

•proc文件系统和sys系统

/proc/ /sys/

这快文件系统是虚拟的，只有动态内存，没有静态内存，一般都用于调试。

\-----------------------------------------------------------------------

\------------------------------------------------------------------------------------

• 进程

main函数的返回值返回给谁，它被谁调用？？

main函数被系统调用，其实是在运行阶段，链接

argc argv 怎么传递参数的？

通过shell采集到参数，然后通过系统，加载器加载到代码中运行

atexit :当程序结束时，运行时的代码，栈原理运行，先入后出。

•程序运行有两种方式结束：

（1）正常结束

（2）强制结束

return 0 exit ：

\_exit：扛把子。直接退出，不运行系统结束的时的函数。

进程

•环境变量：

许多程序，在本机开发环境中可以执行，一换机器就不能执行，这大部分都是环境变量的问题。我们可以通过export打印出环境变量。

在程序中也可以使用environ变量去打印。

environ是一个字符串数组，所以应该是一个二重指针。

getenv 函数获取一个环境变量

•虚拟地址

虚拟地址就是，每个进程都分配了4G的逻辑内存，其中0-1G为OS,1-4G为应用使用内存，然而实际它是操作系统分配的虚拟地址，当每个进程需要一定内存，就去物理内存上去获取，这有点像银行储蓄。

![Image 1][]

虚拟地址的作用？

（1）进程隔离，因为进程是独立的虚拟地址，所以相互独立。

（2）提供多进程共同运行。

•进程进入：

ps -aux ：向终端打印所有的进程

进程控制块:PCB 就是一个数据结构，用来管理新进的一些信息。

进程ID:getpid getppid

多进程的调度原理：进程间相互调度，所以在微观上是串行的，而在宏观上是并行的。合理的进程调度，提高效率。

•fork函数：

fork函数会返回两个进程，一个父进程，一个子进程，内部实现的原理是，当需要产生一个新的进程时，就从老的拷贝一份

子进程：

子进程和父进程的关系 子进程有自己的PCB 子进程被内核同等调度。

•父子进程对文件的操作：

（1）打开同一个文件， 接续的，因为同一个文件打开，文件指针会置位。

（2）分别打开同一个文件，分别的，因为两个进程有两个文件管理表，所以文件指针时分别的，需要加O\_APPEND

子进程的最终目的就是实现独立的运行程序。

**•****进程的诞生和消亡：**

（1）进程0，1（init）

（2）fork

（3）vfork

僵尸进程：

父进程会fork出来一个子进程，当子进程运行结束时，操作系统会回收子进程的资源，但是剩下8K的管理内存没回收，此为僵尸进程。其实就是子进程运行完毕没被父进程回收。

可以显示的用wait/waitpid回收。

孤儿进程：

父进程先死了，所以没人给正在运行的子进程回收，这是系统会自动把这个进程分配init进程（进程1）做为它的父进程(找个老爸)。

**•****wait:**

（请阐述wait这个系统调用的原理）

父进程会利用一个系统调用显示的回收子进程，这个系统调用就是wait,当需要回收是会遇到两个问题

（1）子进程先运行，然后运行结束，父进程回收子进程，正常情况

（2）父进程先运行，子进程还没运行结束，那么他需要等待子进程结束，这就是wait系统调用的阻塞原理，他会把父进程阻塞，然后等待子进程的结束。

那么当父进程没有子进程的时间，wait会怎么样呢？当然不会一直阻塞在那里。它会以错误形式返回一个-1；

wait的参数

原型如下 pid\_t wait(int \*status);

它的输入参数中有一个输出型参数（没加const）,这个status,就会返回回收的子进程的状态，结合下面几个宏定义。

WIFEXITED

\-> 是不是正常终止，正常终止返回1，否则返回0

WEXITSTATUS

\-> 返回子进程的结束状态，也就是返回值。

WIFSIGNALED

\-> 是不是非正常终止（信号）正常终止返回1，否则返回0

#include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/wait.h>
    
    /************************
     * wait回收进程和status
     ************************/
     //wait，默认阻塞式回收子进程，通过传入的status,与响应的宏进程比较可以获取到进程的响应信息
    int main(int argc, const char *argv[])
    { 
     
     pid_t pid = -1;
     pid = fork();
     int status;
     if (pid == 0)
     { 
     printf("这是子进程%d.\n", getpid());
     return 120;
     }
     if (pid > 0)
     { 
     printf("这是父进程%d.\n", getpid());
     pid = wait(&status);
     printf("回收的进程号是%d.\n", pid);
     }
     if (WIFEXITED(status))
     { 
     printf("\n程序正常终止.\n");
     }
     
     if (WIFSIGNALED(status))
     printf("程序非正常终止.\n");
     
     printf("程序的返回状态为%d.\n", WEXITSTATUS(status));
     return 0;
    }

waitpid:

原型如下：pid\_t waitpid(pid\_t pid, int \*status, int options);

可以指定的回收某个进程，可以选择是否采用阻塞非阻塞模式。

（1）waitpid(-1, &status, 0)

\-1：不指定pid,收回任意满足条件的子进程，0，阻塞式，其实就和wait( )功能基本一样。

（2）waitpid(-1, &status, WNOHANG);

不固定某个pid,使用非阻塞式，也有两种情况

1.父进程先执行，然后调用wait,子进程还没执行完，那么直接返回0.

2.给父进程加了sleep，在父进程休眠的这段时间，子进程运行结束，然后父进程唤醒，回收子进程。

(3)固定某个不存在的pid,使用阻塞式

因为waitpid可以指定回收某个进程号，所以当我们指定一个不存在的进程号，而且采用阻塞式的，那么它就会返回一个错误，因为操作系统的设计是很合理的，不可能让程序在原地卡死。

#include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/wait.h>
    
    /************************
     * waitpid与阻塞非阻塞
     ************************/
     //waitpid可以用户自定义阻塞与非阻塞式回收子进程，可以指定或不指定(-1)回收子进程；
    int main(int argc, const char *argv[])
    { 
     pid_t pid = -1;
     pid = fork();
     int status;
     if (pid == 0)
     { 
     printf("子进程：%d.\n ", getpid());
     }
     if (pid > 0)
     { 
     
    #if 0
     //(1)不固定某个pid,切使用默认项，就是阻塞式的
     printf("父进程：%d.\n", getpid());
     pid = waitpid(-1, &status, 0);
     printf("被回收的进程为：%d.\n", pid);
    #endif
    
    #if 0 
     sleep(1);
     //(2)不固定某个pid,使用非阻塞式
     printf("父进程：%d.\n", getpid());
     pid = waitpid(-1, &status, WNOHANG);
     printf("被回收的进程为：%d.\n", pid);
    #endif
    
    #if 1 
     //sleep(1);
     //(3)固定某个不存在的pid,使用阻塞式
     printf("父进程：%d.\n", getpid());
     pid = waitpid(pid+3, &status, 0);
     printf("被回收的进程为：%d.\n", pid);
    #endif
     
     }
     
     return 0;
    }

**•****exec族函数:**

（请阐述exec族函数调用的原理）

通过传参，指定要执行程序的路径，然后执行程序

export：终端显示系统的环境变量

echo &PATH 。。。。

execl，直接加参数，参数后要加NULL

execv，通过定义一个字符串数组指针，要加NULL

#include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/wait.h>
    
    /************************
     * execl,execv,调用函数
     ************************/
     //exec族函数：用来在进程中调用一个已经写好的程序 v就是传参不太一样
    int main(int argc, const char *argv[])
    { 
     pid_t pid;
     pid = fork();
     if (pid > 0)
     { 
     printf("父进程进程号：%d.\n", getpid());
     }
     
     if (pid == 0)
     { 
     printf("子进程进程号：%d.\n", getpid());
     /*
     char *const argv[] = {"ls", "-la", NULL};
     execv("/bin/ls", argv);
     */
     char *const argv[] = {NULL};
     execv("./exe", argv);
     }
     
     
    
     return 0;
    }

execlp,execvp,

如果不加p，那么让找不到给定路径的程序时，则会返回错误值，加了p以后如果找不到就回去系统默认添加的PATH里去找。

#include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/wait.h>
    
    /************************
     * execlp,execvp,调用函数
     ************************/
     //P:exec不加P，就只会在指定目录查找一次，没有则返回错误，带P，还会到系统默认的目录查找一次。PATH的意思。
    int main(int argc, const char *argv[])
    { 
     pid_t pid = -1;
     pid = fork();
     if (pid > 0)
     { 
     printf("父进程PID:%d.\n", getpid());
     }
     if (pid == 0)
     { 
     char *const arg[] = {"ls", "-la", NULL};
     printf("子进程：.\n");
     execvp("ls", arg);
     }
     
     return 0;
    }

execle,execve,

即多传一个参数，环境变量

**•****进程的状态和system函数**

（1）进程的五种状态:(请阐述进程运行的各种状态)

1.就绪态具备一切运行条件，等待CPU调度

2.运行态正在占用CPU

3.僵尸态运行结束，但还未被回收

4.等待态 （浅度休眠）（深度休眠）

浅度休眠，是正在等待某个条件，或者某个条件，但是可以通过信号去唤醒

深度睡眠，是一定需要某个条件，等待资源的到来以后才会唤醒（比如文件要读写，但是硬盘被占用，他就需要硬盘的占用结束，然后才能进行工作，这是硬盘占用结束就是等到了资源，这是间程序就会唤醒）

5.暂停态收到信号，暂时停止，但不是真正的停止。真正的停止是僵尸态。

（2）各个进程的状态图

system函数

（1）system是原子操作的，原子操作就是一种不可打断的操作，他的执行一定要结束，所以会长时间占用CPU.这种操作可以避免竞争状态的产生

与之相反，fork+exec就不是原子的，当我们不需要原子操作时，就可以用fork+exec。

（2）用system函数使用ls命令

int system(const char \*command);

直接加入要执行的PATH名即可

**•****进程关系**

（1）无关系

（2）父子关系

（3）进程组（group）

许多进程不好管理，所以需要一个群体管理，便于某些进程有相互需要时的作用。

（4）会话（session）

就是进程组的集群。

**•****守护进程**

查看进程的命令

（1）ps -ajx

（2）ps -aux

守护进程：（请阐述守护进程的基本特性）

(daemon)守护进程是一般以d结尾,与控制台脱离的后台运行程序，它都是在后台运行，一般用于服务器程序。长期运行

1、syslogd

系统日志守护进程

2、cron

操作系统中时间管理， 比如linux中的需要定时程序。

自己编写守护进程

任何程序都能变成守护进程，主要是看它有没有必要。

编程实现守护进程的步骤：

（1）：子进程等待父进程退出，自己独立

（2）：子进程使用setsid建立一个新的会话期，脱离控制台

函数 setsid

（3）：调用chdir将工作目录修改到/用户主目录下

函数chdir

（4）：将umask设置成0，使得文件的权限最大

函数umask

（5）：关闭所有文件描述符，这里因为要动态获取一个文件描述符的最大值，所以需要调用sysconf

函数sysconf ，可以获取系统的参数

（6）：将文件 0 1 2 定位到/dev/null 垃圾堆。

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/stat.h>
    #include <errno.h>
    #include <fcntl.h>
    void creat_daemon(void);
    /************************
     * 守护进程的编写制作 *
     ************************/
     //守护进程就是一个后台运行的进程，代码实现如下：
    int main(int argc, const char *argv[])
    { 
     creat_daemon();
     while (1)
     { 
     printf("im runing .\n");
     }
    
     return 0;
    }
    
    void creat_daemon(void)
    { 
     //子进程等待父进程结束
     pid_t pid = -1;
     pid = fork();
     if (pid < 0)
     { 
     perror("fork");
     exit(-1);
     }
     if (pid > 0)
     { 
     //这里就是父进程了，直接退出
     exit(0);
     }
    
     if (pid ==0 )
     { 
     //下面就是子进程
    
     //(1)调用setsid,建立一个会话期使其与控制台脱离 
     //原型：pid_t setsid(void);
     pid = setsid();
     if (-1 == pid)
     { 
     perror("setsid");
    
     }
     //(2)将用户工作目录修改到 /目录下，保证安全，
     chdir("/");
    
     //(3)将umask设置为0
     umask(0);
    
     //(4)关闭所有文件描述符，因为系统不同所以文件描述符的大小也不定，这里我们调用一个函数去动态获取这个值
     int cnt = sysconf(_SC_OPEN_MAX);
     int i = 0;
     for (i=0; i<cnt; i++)
     { 
     close(i);
     }
    
     //(5)将0，1，2重定位到/dev/null
     open("/dev/null", O_RDWR);
     open("/dev/null", O_RDWR);
     open("/dev/null", O_RDWR);
    
     }
     return ;
    }

利用openlog,syslog,closelog将调试信息

（请阐述syslog函数的工作原理）

linux下有一个后台守护进程syslogd,当我们需要系统信息时，syslogd会和syslog,之间开辟一条通道去传输，由此实现了syslog记录日志信息的功能。

这种服务性质的原理在操作系统中有很多

log日志信息在/var/log/syslog下查看

#include <stdio.h>
    #include <syslog.h>
    /************************
     * syslog调试信息 *
     ************************/
     //往日志信息里输入调试信息
    int main(int argc, const char *argv[])
    { 
     //(1)void openlog(const char *ident, int option, int facility);
     openlog("a.out", LOG_PID | LOG_CONS, LOG_USER);
     //上面这个a.out,其实就是你指定一个标号，用来查询日志信息。可以任意修改
     
     //(2)void syslog(int priority, const char *format, ...);
     syslog(LOG_INFO, "This is syslog for a.outlog");
     syslog(LOG_INFO, "This is syslog for a.outlog");
     syslog(LOG_INFO, "This is syslog for a.outlog");
     //(3)void closelog(void);
     closelog();
     
     return 0;
    }

**•****让程序单一运行：**

原理：就是在程序运行是创建一个文件，然后当有进程要运行时去检测这个文件在不在，如果存在，就表示进程正在运行，否则就不在运行；

利用的函数

注意创建文件的目录。如果在根目录下，那么权限可能有问题。

（1）open()O\_CREAT, O\_EXEC（如果文件存在则会报错，errno会被置位，可以通过errno判断）

（2）atexit需要在结束时清理掉创建的文件

（3）remove删除文件

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <errno.h>
    /************************
     * 让程序单次运行的技巧 *
     ************************/
     //原理：当程序执行时创建一个怪异的文件，当程序再次执行时去检查这个文件是否存在，存在则禁止执行，当程序结束则删除这个文件。
     void delay_file(void);
    #define FILE_NAME "/var/my_singel" //注意，在根目录下的权限，一般是无法创建文件的所以可能无法执行创建文件操作
    int main(int argc, const char *argv[])
    { 
     int fd = -1;
     fd = open(FILE_NAME, O_RDWR | O_TRUNC | O_CREAT | O_EXCL, 0666);
     if (fd < 0)
     { 
     if (errno == EEXIST)
     { 
     printf("请勿重复运行.\n");
     return -1;
     }
     }
     
     printf("打开成功.\n");
     
     atexit(delay_file);
     
     int i = 20;
     while (i-->0)
     { 
     printf("I am runing ....\n");
     sleep(1);
     }
     
     
     
     
     
     return 0;
    }
    
    void delay_file(void)
    { 
     remove(FILE_NAME);
    }

**•****LINUX下IPC(进程间通信)**

管道 (无名管道):

![Image 1][]

（1）原理：就是在内核中开辟一段空间（pipe），然后利用子进程继承父进程的文件描述符的特性，然后进行读写，但是通信方式是半双工的，就是同时智能实现单边通信（pipe）创建后，会返回两个文件描述符，分别读写。

（父进程fork子进程后，子进程继承父进程的管道fd,然后进行通信，发送端、接收端同时只能一个）

（2）缺点：只是适用于父子进程间通信。

如图则是双工的实现

管道 (有名管道):fifo

通过一个指定的文件名，利用mkfifo，利用open分别获取这个文件的fd,然后一个读一个写。

system V IPC

**（1）消息队列（fifo）**

类似于链表先入先出，进程间通信时通过建立一个消息队列，一个进程发，一个进程从另一头读

![Image 1][]

**（2）信号量**

有点类似于编程思维中的flg,标号，其实信号量就是一个变量，当信号量为特定数时开始发送信号，信号量为特定数时开始接收信号。

**（3）共享内存**

![Image 1][]

linux下，前面两种通信速率都比较慢，而共享内存的通信办法就比较快速，这里是通过在内核中开辟一块内存，进程1将自己需要和进程2通信的信息放在这块内存中，进程2去读取即可，这里的内存和进程1,2之间有这虚拟映射，就避免了给进程2拷贝的副作用（如果不用共享内存则通信的话就需要拷贝）

举个栗子：

进程1是摄像头程序，它需要将拍的照片，传送给进程2处理压缩、编解码，那么有两种办法

（1）拷一份给他

（2）就是用上面的共享内存，但是共享内存有一个问题，万一进程1还没往共享内存里放完，进程2就开始读了，怎么办？这里就又需要信号的配合了，其实许多硬件都有这样的特性，共享内存有这广泛的使用。

**•** **信号**

(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)SIGALRM 14 涉及alarm函数的实现

(8)SIGTERM 15

kill命令发送的OS默认终止信号

(9)SIGCHLD 17

子进程终止或停止时OS向其父进程发此信号

(10)SIGUSR1 10

用户自定义信号，作用和意义由应用自己定义

SIGUSR2 12

两个函数

（1）signal

（2）sigactonal 很类似，

（3）alarm 定时闹钟，同时操作系统只能响应一个alarm，所以alarm会覆盖前面。

（4）pause 将cpu挂起。

//宏的定义在/usr/include/i386-linux-gnu/bits/signum.

[Image 1]: 
[SouthEast]: /images/20220612/0f82b0f32ff4455ebe2405f3ac724487.png
[SouthEast 1]: /images/20220612/0304dbf7e2594a91ba0e7eb9ed816dbb.png
[SouthEast 2]: /images/20220612/66a0abf8aa67436dbb1df7538ba08358.png
[SouthEast 3]: /images/20220612/f485270d9e1644ae8927667d88f1e27f.png
[SouthEast 4]: /images/20220612/acd05fcae18a40aeb8de8e03396a1dc2.png
[SouthEast 5]: /images/20220612/98aa7d732c4c4c48a3d696c8ffebd68a.png