Linux进程
Linux进程介绍
程序和进程
程序，是指编译好的二进制文件，在磁盘上，不占用系统资源(cpu、内存、打开的文件、设备、锁…)
进程，是一个抽象的概念，与操作系统原理联系紧密。进程是活跃的程序，占用系统资源。在内存中执行。(程序运行起来，产生一个进程)
程序 → 剧本(纸) 进程 → 戏(舞台、演员、灯光、道具…)
同一个剧本可以在多个舞台同时上演。同样，同一个程序也可以加载为不同的进程(彼此之间互不影响)
如：同时开两个终端。各自都有一个bash但彼此ID不同。
进程并发
并发，在操作系统中，一个时间段中有多个进程都处于已启动运行到运行完毕之间的状态。但，任一个时刻点上仍只有一个进程在运行。
例如，当下，我们使用计算机时可以边听音乐边聊天边上网。 若笼统的将他们均看做一个进程的话，为什么可以同时运行呢，因为并发。
CPU和MMU
CPU（Central Processing Unit 中央处理器）
MMU（Memory Management Unit 内存管理单元）
MMU主要作用：
- 完成虚拟内存与物理内存的映射。
.data段（数据段）和.text段（代码段）的数据映射到物理内存的单位是4k - 设置修改内存访问级别
linux中内存访问级别有两种。一种是0级，kernel可以访问所有内存。一种是3级，user可以访问自己进程的内存。
PCB
PCB（Process Control Block 进程控制块）
我们知道，每个进程在内核中都有一个进程控制块（PCB）来维护进程相关的信息，Linux内核的进程控制块是task_struct结构体。
linux中查看结构体位于/usr/目录中哪个文件路径：
# grep -r "task_struct {" /usr/
/usr/src/linux-headers-3.16.0-30/include/linux/sched.h文件中可以查看struct task_struct 结构体定义。其内部成员有很多，我们重点掌握以下部分即可：
- 进程id。系统中每个进程有唯一的id，在C语言中用pid_t类型表示，其实就是一个非负整数。
- 进程的状态，有就绪、运行、挂起、停止等状态。
- 进程切换时需要保存和恢复的一些CPU寄存器。
- 描述虚拟地址空间的信息。虚拟地址空间到物理内存地址空间的映射表。
- 描述控制终端的信息。
- 当前工作目录（Current Working Directory）。可通过chdir()改变进程当前工作目录。
- umask掩码。
- 文件描述符表，包含很多指向file结构体的指针。
- 和信号相关的信息。
- 用户id和组id。
- 会话（Session）和进程组。
- 进程可以使用的资源上限（Resource Limit）。可通过
ulimit -a查看当前linux资源上限。
进程状态
进程基本的状态有5种。分别为初始态，就绪态，运行态，挂起态与终止态。其中初始态为进程准备阶段，常与就绪态结合来看。
环境变量
环境变量，是指在操作系统中用来指定操作系统运行环境的一些参数。通常具备以下特征：
① 字符串(本质)
② 有统一的格式：名=值[:值]
③ 值用来描述进程环境信息。
存储形式：与命令行参数类似。char *[]数组，数组名environ，内部存储字符串，NULL作为哨兵结尾。
使用形式：与命令行参数类似。
加载位置：与命令行参数类似。位于用户区，高于stack的起始位置。
引入环境变量表：须声明环境变量。extern char ** environ;
打印当前进程的所有环境变量：
#include <stdio.h>
extern char **environ;
int main(void) {
int i;
for(i = 0; environ[i] != NULL; i++){
printf("%s\n", environ[i]);
}
return 0;
}
常见环境变量
按照惯例，环境变量字符串都是name=value这样的形式，大多数name由大写字母加下划线组成，一般把name的部分叫做环境变量，value的部分则是环境变量的值。环境变量定义了进程的运行环境，一些比较重要的环境变量的含义如下：
PATH
可执行文件的搜索路径。ls命令也是一个程序，执行它不需要提供完整的路径名/bin/ls，然而通常我们执行当前目录下的程序a.out却需要提供完整的路径名./a.out，这是因为PATH环境变量的值里面包含了ls命令所在的目录/bin，却不包含a.out所在的目录。PATH环境变量的值可以包含多个目录，用:号隔开。在Shell中用echo命令可以查看这个环境变量的值：$echo $PATH
SHELL
当前Shell，它的值通常是/bin/bash。
TERM
当前终端类型，在图形界面终端下它的值通常是xterm，终端类型决定了一些程序的输出显示方式，比如图形界面终端可以显示汉字，而字符终端一般不行。
LANG
语言和locale，决定了字符编码以及时间、货币等信息的显示格式。
HOME
当前用户主目录的路径，很多程序需要在主目录下保存配置文件，使得每个用户在运行该程序时都有自己的一套配置。
设置环境变量函数
getenv函数
#include <stdlib.h>
//获取环境变量值
char *getenv(const char *name); //成功：返回环境变量的值；失败：NULL (name不存在)
setenv函数
#include <stdlib.h>
//设置环境变量的值
int setenv(const char *name, const char *value, int overwrite);
//成功：0；失败：-1
//参数overwrite取值： 1：覆盖原环境变量 0：不覆盖。(该参数常用于设置新环境变量，如：ABC = haha-day-night)
unsetenv函数
#include <stdlib.h>
//删除环境变量name的定义
int unsetenv(const char *name);
//成功：0；失败：-1
//注意事项：name不存在仍返回0(成功)，当name命名为"ABC="时则会出错。
Linux进程控制
创建子进程（fork函数）
作用：创建一个子进程。
#include <unistd.h>
pid_t fork(void);
//失败返回-1；
//成功返回：
① 父进程返回子进程的ID(非负)
② 子进程返回 0
//pid_t类型表示进程ID，但为了表示-1，它是有符号整型。(0不是有效进程ID，init最小，为1)
//注意返回值，不是fork函数能返回两个值，而是fork后，fork函数变为两个，父子需【各自】返回一个。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
int i;
pid_t pid;
printf("fork_test start\n");
for (i = 0; i < 5; i++) {
pid = fork();
if (pid == 0) { //fork返回值==0,说明是子进程
break;
}
}
if (i < 5) {
sleep(i);
printf("I'am %d child , pid = %u, ppid =%u\n", i+1, getpid(), getppid());
} else {
sleep(i);
printf("I'm parent, pid = %u, ppid =%u\n",getpid(), getppid());
}
return 0;
}
运行结果：
# gcc fork_test.c -o fork_test --Wall
# ./fork_test
fork_test start
I'am 1 child , pid = 4034, ppid =4033
I'am 2 child , pid = 4035, ppid =4033
I'am 3 child , pid = 4036, ppid =4033
I'am 4 child , pid = 4037, ppid =4033
I'am 5 child , pid = 4038, ppid =4033
I'm parent, pid = 4033, ppid =3567
# ps aux | grep 3567
root 3567 0.0 0.2 115676 2168 pts/1 Ss 15:10 0:00 -bash
root 4040 0.0 0.0 110412 888 pts/1 R+ 18:55 0:00 grep --color=auto 3567
# ps ajx //查看进程父进程id、组id
结论：
- fork()返回值为0，代表当前进程是子进程
- fork()返回值大于0，代表当前进程是父进程
- 在bash中执行的进程的父进程是bash。如上所示，在命令行中执行./fork_test创建的进程，它的父进程是-bash
- 在bash命令行输入可执行程序，会fork出进程来执行。如上所示，在命令行中执行./fork_test创建的进程，它的父进程是-bash
查看进程信息的一些函数
区分一个函数是“系统函数”还是“库函数”依据：
- 是否访问内核数据结构
- 是否访问外部硬件资源
二者有任一 → 系统函数；二者均无 → 库函数
//获取当前进程ID
pid_t getpid(void);
//获取当前进程的父进程ID
pid_t getppid(void);
//获取当前进程实际用户ID
uid_t getuid(void);
//获取当前进程有效用户ID
uid_t geteuid(void);
//获取当前进程使用用户组ID
gid_t getgid(void);
//获取当前进程有效用户组ID
gid_t getegid(void);
进程共享：
父子进程之间在fork后。有哪些相同，那些相异之处呢？
刚fork之后：
父子相同处: 全局变量、.data、.text、栈、堆、环境变量、用户ID、宿主目录、进程工作目录、信号处理方式…
父子不同处: 1.进程ID 2.fork返回值 3.父进程ID 4.进程运行时间 5.闹钟(定时器) 6.未决信号集
似乎，子进程复制了父进程0-3G用户空间内容，以及父进程的PCB，但pid不同。真的每fork一个子进程都要将父进程的0-3G地址空间完全拷贝一份，然后在映射至物理内存吗？
当然不是!父进程调用fork()后，父子进程间遵循【读时共享，写时复制】的原则。这样设计，无论子进程执行父进程的逻辑还是执行自己的逻辑都能节省内存开销。
【重点】：父子进程共享：1. 文件描述符(打开文件的结构体) 2. mmap建立的映射区 (进程间通信详解)
特别的，fork之后父进程先执行还是子进程先执行不确定。取决于内核所使用的调度算法。
gdb调试-设置调试父子进程：
使用gdb调试的时候，gdb只能跟踪一个进程。可以在fork函数调用之前，通过指令设置gdb调试工具跟踪父进程或者是跟踪子进程。默认跟踪父进程。
set follow-fork-mode child 命令设置gdb在fork之后跟踪子进程。
set follow-fork-mode parent 设置跟踪父进程。
注意，一定要在fork函数调用之前设置才有效。
子进程切换执行的代码（exec函数族）
fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。
将当前进程的.text、.data替换为所要加载的程序的.text、.data，然后让进程从新的.text第一条指令开始执行，但进程ID不变，换核不换壳。
其实有六种以exec开头的函数，统称exec函数：
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);
execlp函数
//加载一个进程，借助PATH环境变量
int execlp(const char *file, const char *arg, ...);
//成功：无返回；失败：-1
//参数1：要加载的程序的名字。该函数需要配合PATH环境变量来使用，当PATH中所有目录搜索后没有参数1则出错返回。
该函数通常用来调用系统程序。如：ls、date、cp、cat等命令。
execl函数
//加载一个进程， 通过 路径+程序名 来加载。
int execl(const char *path, const char *arg, ...);
//成功：无返回；失败：-1
对比execlp，如加载"ls"命令带有-l，-F参数
execlp("ls", "ls", "-l", "-F", NULL); 使用程序名在PATH中搜索。
execl("/bin/ls", "ls", "-l", "-F", NULL); 使用参数1给出的绝对路径搜索。
execvp函数
//加载一个进程，使用自定义环境变量env
int execvp(const char *file, const char *argv[]);
//变参形式： ①... ② argv[] (main函数也是变参函数，形式上等同于 int main(int argc, char *argv0, ...))
//变参终止条件：① NULL结尾 ② 固参指定
execvp与execlp参数形式不同，原理一致。
exec函数族一般规律
exec函数一旦调用成功即执行新的程序，不返回。只有失败才返回，错误值-1。所以通常我们直接在exec函数调用后直接调用perror()和exit()，无需if判断。
l (list) 命令行参数列表
p (path) 搜素file时使用path变量
v (vector) 使用命令行参数数组
e (environment) 使用环境变量数组,不使用进程原有的环境变量，设置新加载程序运行的环境变量
事实上，只有execve是真正的系统调用，其它五个函数最终都调用execve，所以execve在man手册第2节，其它函数在man手册第3节。这些函数之间的关系如下图所示。
execl示例代码
#include <stdio.h>
#include <unistd.h>
int main(void)
{
pid_t pid = fork();
if (pid > 0) {
execl("/home/ronghui/test/process_test/exec/output", "output", NULL);
} else if (pid == 0) {
printf("i'm parent pid = %d\n", getpid());
}
return 0;
}
execlp示例代码
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int fd;
fd = open("ps.out", O_WRONLY|O_CREAT|O_TRUNC, 0644);
if(fd < 0){
perror("open ps.out error");
exit(1);
}
//文件描述符重定向
//STDOUT_FILENO代表文件描述符3号位置，是标准输出
//把fd文件描述符指针复制到STDOUT_FILENO所在的位置
//意思就是现在STDOUT_FILENO所在位置的文件描述符指针，现在指向了fd
dup2(fd, STDOUT_FILENO);
execlp("ps", "ps", "ax", NULL);
//如果exec族函数调用成功 不会往下执行 perror不会被执行。除非exec族函数调用失败
perror(exec error);
exit(1);
//close(fd);
return 0;
}
execv示例代码
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
printf("========================\n");
char *argvv[] = {"ls", "-l", "-F", "R", "-a", NULL};
pid_t pid = fork();
if (pid == 0) {
execl("/bin/ls", "ls", "-l", "-F", "-a", NULL);
execv("/bin/ls", argvv);
perror("execlp");
exit(1);
} else if (pid > 0) {
sleep(1);
printf("parent\n");
}
return 0;
}
回收子进程（wait/waitpid函数）
孤儿进程
孤儿进程: 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。
僵尸进程
僵尸进程: 进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。
特别注意，僵尸进程是不能使用kill命令清除掉的。因为kill命令只是用来终止进程的，而僵尸进程已经终止。思考！用什么办法可清除掉僵尸进程呢？
答：杀其父进程，然后该僵尸进程变成孤儿进程，init进程发现该进程是僵尸进程就会回收其PCB。
wait函数
一个进程在终止时会关闭所有文件描述符，释放在用户空间分配的内存，但它的PCB还保留着，内核在其中保存了一些信息：如果是正常终止则保存着退出状态，如果是异常终止则保存着导致该进程终止的信号是哪个。这个进程的父进程可以调用wait或waitpid获取这些信息，然后彻底清除掉这个进程。我们知道一个进程的退出状态可以在Shell中用特殊变量$?查看，因为Shell是它的父进程，当它终止时Shell调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。
父进程调用wait函数可以回收子进程终止信息。该函数有三个功能：
① 阻塞等待子进程退出
② 回收子进程残留资源
③ 获取子进程结束状态(退出原因)。
#include <sys/wait.h>
pid_t wait(int *status); //成功：清理掉的子进程ID；失败：-1 (没有子进程)
当进程终止时，操作系统的隐式回收机制会：
1.关闭所有文件描述符
2. 释放用户空间分配的内存。内核的PCB仍存在。其中保存该进程的退出状态。(正常终止→退出值；异常终止→终止信号)
可使用wait函数传出参数status来保存进程的退出状态。借助宏函数来进一步判断进程终止的具体原因。宏函数可分为如下三组：
- WIFEXITED(status) 为非0 → 进程正常结束
WEXITSTATUS(status) 如上宏为真，使用此宏 → 获取进程退出状态 (exit的参数) - WIFSIGNALED(status) 为非0 → 进程异常终止
WTERMSIG(status) 如上宏为真，使用此宏 → 取得使进程终止的那个信号的编号。 - WIFSTOPPED(status) 为非0 → 进程处于暂停状态
WSTOPSIG(status) 如上宏为真，使用此宏 → 取得使进程暂停的那个信号的编号。
WIFCONTINUED(status) 为真 → 进程暂停后已经继续运行
wait函数示例代码
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>
int main(void)
{
pid_t pid, wpid;
int status;
pid = fork();
if(pid == -1){
perror("fork error");
exit(1);
} else if(pid == 0){ //son
printf("I'm process child, pid = %d\n", getpid());
#if 1
execl("./abnor", "abnor", NULL);
perror("execl error");
exit(1);
#endif
sleep(1);
exit(10);
} else {
//wpid = wait(NULL); //传出参数
wpid = wait(&status); //传出参数
if(WIFEXITED(status)){ //正常退出
printf("I'm parent, The child process "
"%d exit normally\n", wpid);
printf("return value:%d\n", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) { //异常退出
printf("The child process exit abnormally, "
"killed by signal %d\n", WTERMSIG(status));
//获取信号编号
} else {
printf("other...\n");
}
}
return 0;
}
waitpid函数
作用同wait，但可指定pid进程清理，可以不阻塞。
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, in options);
//成功：返回清理掉的子进程ID；失败：-1(无子进程)
特殊参数和返回情况：
参数pid：
> 0 回收指定ID的子进程
-1 回收任意子进程（相当于wait）
0 回收和当前调用waitpid一个组的所有子进程
< -1 回收指定进程组内的任意子进程
参数options：
0 阻塞
WNOHANG 非阻塞
返回值：
如果返回0：且参3为WNOHANG，则子进程正在运行，暂时不可回收
如果返回>0 表示回收成功，返回回收的pid
如果返回-1 表示失败(无子进程)
注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。
waitpid函数示例代码
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main(int argc, char *argv[])
{
int n = 5, i;
pid_t p, q;
if(argc == 2){
n = atoi(argv[1]);
}
q = getpid();
for(i = 0; i < n; i++) {
p = fork();
if(p == 0) {
break;
}
}
if(n == i){ // parent
sleep(n);
printf("I am parent, pid = %d\n", getpid());
for (i = 0; i < n; i++) {
p = waitpid(0, NULL, WNOHANG);
printf("wait pid = %d\n", p);
}
} else {
sleep(i);
printf("I'm %dth child, pid = %d\n",
i+1, getpid());
}
return 0;
}
Linux进程间通信
进程间通信(IPC方法)
Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。
在进程间完成数据传递需要借助操作系统提供特殊的方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身设计缺陷被淘汰或者弃用。现今常用的进程间通信方式有：
① 管道 (使用最简单)
② 信号 (开销最小)
③ 共享映射区 (无血缘关系)
④ 本地套接字 (最稳定)
管道(PIPE)
管道的概念：
管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质：
1. 其本质是一个伪文件(实为内核缓冲区)
2. 由两个文件描述符引用，一个表示读端，一个表示写端。
3. 规定数据从管道的写端流入管道，从读端流出。
伪文件概念
linux系统一共有7钟文件类型。
其中真正占用磁盘存储的文件类型是：-（文件）、d（目录）、l（符号链接）
不真正占用磁盘存储的文件类型称为伪文件：s（套接字）、b（块设备）、c（字符设备）、p（管道）
管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
管道的局限性：
① 数据自己读不能自己写。
② 数据一旦被读走，便不在管道中存在，不可反复读取。
③ 由于管道采用半双工通信方式。因此，数据只能在一个方向上流动。
④ 只能在有公共祖先的进程间使用管道。
常见的通信方式有，单工通信、半双工通信、全双工通信。
pipe函数
#include <unistd.h>
//创建管道
int pipe(int pipefd[2]); 成功：0；失败：-1，设置errno
函数调用成功返回r/w两个文件描述符。无需open，但需手动close。规定：fd[0] → r； fd[1] → w，就像0对应标准输入，1对应标准输出一样。向管道文件读写数据其实是在读写内核缓冲区。
管道创建成功以后，创建该管道的进程（父进程）同时掌握着管道的读端和写端。如何实现父子进程间通信呢？通常可以采用如下步骤：
- 父进程调用pipe函数创建管道，得到两个文件描述符fd[0]、fd[1]指向管道的读端和写端。
- 父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一管道。
- 父进程关闭管道读端，子进程关闭管道写端。父进程可以向管道中写入数据，子进程将管道中的数据读出。由于管道是利用环形队列实现的，数据从写端流入管道，从读端流出，这样就实现了进程间通信。
管道的读写行为
使用管道需要注意以下4种特殊情况（假设都是阻塞I/O操作，没有设置O_NONBLOCK标志）：
- 如果所有指向管道写端的文件描述符都关闭了（管道写端引用计数为0），而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次read会返回0，就像读到文件末尾一样。
- 如果有指向管道写端的文件描述符没关闭（管道写端引用计数大于0），而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读端读数据，那么管道中剩余的数据都被读取后，再次read会阻塞，直到管道中有数据可读了才读取数据并返回。
- 如果所有指向管道读端的文件描述符都关闭了（管道读端引用计数为0），这时有进程向管道的写端write，那么该进程会收到信号SIGPIPE，通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉，不终止进程。具体方法信号章节详细介绍。
- 如果有指向管道读端的文件描述符没关闭（管道读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次write会阻塞，直到管道中有空位置了才写入数据并返回。
总结：
① 读管道：
1. 管道中有数据，read返回实际读到的字节数。
2. 管道中无数据：
(1) 管道写端被全部关闭，read返回0 (好像读到文件结尾)
(2) 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)
② 写管道：
1. 管道读端全部被关闭， 进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)
2. 管道读端没有全部关闭：
(1) 管道已满，write阻塞。
(2) 管道未满，write将数据写入，并返回实际写入的字节数。
管道缓冲区大小
可以使用ulimit –a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。通常为：
pipe size (512 bytes, -p) 8
也可以使用fpathconf函数，借助参数 选项来查看。
#include <unistd.h>
long fpathconf(int fd, int name); 成功：返回管道的大小 失败：-1，设置errno
管道的优劣
优点：简单，相比信号，套接字实现进程间通信，简单很多。
缺点：
- 只能单向通信，双向通信需建立两个管道。
- 只能用于父子、兄弟进程(有共同祖先)间通信。该问题后来使用fifo有名管道解决。
示例代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void)
{
int fd[2];
pid_t pid;
int i;
int ret = pipe(fd);
if (ret == -1) {
perror("pipe error:");
exit(1);
}
for (i = 0; i < 2; i++){
pid = fork();
if (pid == -1) {
perror("pipe error:"); //ls | wc -l
exit(1);
}
if (pid == 0)
break;
}
if (i == 0) { //兄 ls
close(fd[0]);
dup2(fd[1], STDOUT_FILENO);
execlp("ls", "ls", NULL);
} else if (i == 1) { // 弟 wc -l
close(fd[1]);
dup2(fd[0], STDIN_FILENO);
execlp("wc", "wc", "-l", NULL);
} else if (i == 2) { //父
close(fd[0]);
close(fd[1]);
for(i = 0; i < 2; i++)
wait(NULL);
}
return 0;
}
命名管道(FIFO)
FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间。但通过FIFO，不相关的进程也能交换数据。
FIFO是Linux基础文件类型中的一种。但，FIFO文件在磁盘上没有数据块，仅仅用来标识内核中一条通道。各进程可以打开这个文件进行read/write，实际上是在读写内核通道，这样就实现了进程间通信。
创建方式：
- 命令：mkfifo 管道名
- 库函数：
int mkfifo(const char *pathname, mode_t mode); //成功：0； 失败：-1
一旦使用mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件I/O函数都可用于fifo。如：close、read、write、unlink等。
共享存储映射（mmap）
存储映射I/O
存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。
使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。
mmap函数
#include <sys/mman.h>
void *mmap(void *adrr, size_t length, int prot, int flags, int fd, off_t offset);
返回：成功：返回创建的映射区首地址；失败：MAP_FAILED宏
参数：
addr: 建立映射区的首地址，由Linux内核指定。使用时，直接传递NULL
length： 欲创建映射区的大小
prot： 映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
flags： 标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)
MAP_SHARED: 会将映射区所做的操作反映到物理设备（磁盘）上。
MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。
fd： 用来建立映射区的文件描述符
offset： 映射文件的偏移(4k的整数倍)
munmap函数
同malloc函数申请内存空间类似的，mmap建立的映射区在使用结束后也应调用类似free的函数来释放。
#include <sys/mman.h>
int munmap(void *addr, size_t length); 成功：0； 失败：-1
mmap注意事项
思考：
- 可以open的时候O_CREAT一个新文件来创建映射区吗? 答：不可以，mmap不能创建size为0的映射区，新文件大小必须大于0。
- 如果open时O_RDONLY, mmap时PROT参数指定PROT_READ|PROT_WRITE会怎样？答：不可以，提示权限不足。
- 文件描述符先关闭，对mmap映射有没有影响？答：没有。文件描述符其实就是操作文件的句柄，mmap映射成功后，不需要句柄，而是通过mmap返回的指针地址，也可以操作文件，不过类型需要能写入文件。
- 如果文件偏移量为1000会怎样？答： 不可以，提示无效参数。偏移量必须为4K的整数倍。
- 对mem（mmap创建好的映射区首地址）越界操作会怎样？答：会出错。
- 如果mem（mmap创建好的映射区首地址）++，munmap可否成功？答：不可以。如果对首地址++就不是正确的mmap创建好的映射区首地址，释放错误。
- mmap什么情况下会调用失败？答：各种参数错误都可能导致调用失败。
- 如果不检测mmap的返回值，会怎样？答：很可能会出错。
总结：使用mmap时务必注意以下事项：
- 创建映射区的过程中，隐含着一次对映射文件的读操作。
- 当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
- 映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
- 特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！ mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
- munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
- 如果文件偏移量必须为4K的整数倍
- mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
mmap父子进程通信
父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags：
MAP_PRIVATE: (私有映射) 父子进程各自独占映射区；
MAP_SHARED: (共享映射) 父子进程共享映射区；
结论：父子进程共享：1. 打开的文件 2. mmap建立的映射区(但必须要使用MAP_SHARED)
匿名映射
通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。
使用MAP_ANONYMOUS (或MAP_ANON)， 并且fd置为-1，如:
int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
// "4"随意举例，该位置表大小，可依实际需要填写。
需注意的是，MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义，可使用如下两步来完成匿名映射区的建立。
① fd = open(“/dev/zero”, O_RDWR);
② p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);
mmap无血缘关系进程间通信
实质上mmap是内核借助文件帮我们创建了一个映射区，多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享，因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可。若想实现共享，当然应该使用MAP_SHARED了。
mmap修改文件示例
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
int main(void)
{
int fd = open("./test.txt", O_RDWR);
char *p;
int i;
struct stat sbuf;
stat("./test.txt", &sbuf);
int len = sbuf.st_size;
printf("len = %d\n", len);
p = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (p == MAP_FAILED) {
perror("mmap error");
exit(1);
}
strcpy(p, "hehehe");
for (i = 0; i < len; i++) {
printf("%c", p[i]);
}
printf("\n");
munmap(p, len);
close(fd);
return 0;
}
mmap父子进程之间通信示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
int main(void)
{
int *p;
pid_t pid;
//创建匿名映射区
p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); //MAP_ANONYMOUS
if(p == MAP_FAILED){ //注意:不是p == NULL
perror("mmap error");
exit(1);
}
pid = fork(); //创建子进程
if(pid == 0){
*p = 2000;
printf("child, *p = %d\n", *p);
} else {
sleep(1);
printf("parent, *p = %d\n", *p);
}
munmap(p, 4); //释放映射区
return 0;
}
mmap无血缘关系进程间通信示例
mmap_w.c
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
struct STU {
int id;
char name[20];
char sex;
};
void sys_err(char *str)
{
perror(str);
exit(1);
}
int main(int argc, char *argv[])
{
int fd;
struct STU student = {10, "xiaoming", 'm'};
char *mm;
if (argc < 2) {
printf("./a.out file_shared\n");
exit(-1);
}
fd = open(argv[1], O_RDWR | O_CREAT, 0664);
ftruncate(fd, sizeof(student));
mm = mmap(NULL, sizeof(student), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (mm == MAP_FAILED)
sys_err("mmap");
close(fd);
while (1) {
memcpy(mm, &student, sizeof(student));
student.id++;
sleep(1);
}
munmap(mm, sizeof(student));
return 0;
}
mmap_r.c
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
struct STU {
int id;
char name[20];
char sex;
};
void sys_err(char *str)
{
perror(str);
exit(-1);
}
int main(int argc, char *argv[])
{
int fd;
struct STU student;
struct STU *mm;
if (argc < 2) {
printf("./a.out file_shared\n");
exit(-1);
}
fd = open(argv[1], O_RDONLY);
if (fd == -1)
sys_err("open error");
mm = mmap(NULL, sizeof(student), PROT_READ, MAP_SHARED, fd, 0);
if (mm == MAP_FAILED)
sys_err("mmap error");
close(fd);
while (1) {
printf("id=%d\tname=%s\t%c\n", mm->id, mm->name, mm->sex);
sleep(2);
}
munmap(mm, sizeof(student));
return 0;
}
运行
// 终端1
# ./mmap_w testfile
// 终端2
# ./mmap_r testfile
id=19 name=xiaoming m
id=21 name=xiaoming m
id=23 name=xiaoming m
id=25 name=xiaoming m
id=27 name=xiaoming m
id=29 name=xiaoming m
...
mmap封装匿名映射API示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
void *smalloc(size_t size)
{
void *p;
//创建匿名映射区
p = mmap(NULL, size, PROT_READ|PROT_WRITE,
MAP_SHARED|MAP_ANON, -1, 0);
if (p == MAP_FAILED) {
p = NULL;
}
return p;
}
void sfree(void *ptr, size_t size)
{
munmap(ptr, size);
}
int main(void)
{
int *p;
pid_t pid;
p = smalloc(4);
pid = fork(); //创建子进程
if (pid == 0) {
*p = 2000;
printf("child, *p = %d\n", *p);
} else {
sleep(1);
printf("parent, *p = %d\n", *p);
}
sfree(p, 4);
return 0;
}
套接字 (socket)
略。同网络编程socket。
信号（signal）
略。查看【Linux信号-全局变量异步I/O】
Linux进程间关系
终端
终端：所有输入输出设备的总称。
在UNIX系统中，用户通过终端登录系统后得到一个Shell进程，这个终端成为Shell进程的控制终端（Controlling Terminal），进程中，控制终端是保存在PCB中的信息，而fork会复制PCB中的信息，因此由Shell进程启动的其它进程的控制终端也是这个终端。默认情况下（没有重定向），每个进程的标准输入、标准输出和标准错误输出都指向控制终端，进程从标准输入读也就是读用户的键盘输入，进程往标准输出或标准错误输出写也就是输出到显示器上。信号中还讲过，在控制终端输入一些特殊的控制键可以给前台进程发信号，例如Ctrl-C表示SIGINT，Ctrl-\表示SIGQUIT。
字符终端：Alt + Ctrl + F1、F2、F3、F4、F5、F6
伪终端: pts (pseudo terminal slave) 。
-图形终端：Alt + F7
-网络终端：SSH、Telnet...
终端的启动流程
文件与I/O中讲过，每个进程都可以通过一个特殊的设备文件/dev/tty访问它的控制终端。事实上每个终端设备都对应一个不同的设备文件，/dev/tty提供了一个通用的接口，一个进程要访问它的控制终端既可以通过/dev/tty也可以通过该终端设备所对应的设备文件来访问。ttyname函数可以由文件描述符查出对应的文件名，该文件描述符必须指向一个终端设备而不能是任意文件。
简单来说，一个Linux系统启动，大致经历如下的步骤：
init --> fork --> exec --> getty --> 用户输入帐号 --> login --> 输入密码 --> exec --> bash
line disciline 线路规程：用来过滤键盘输入的内容。
硬件驱动程序负责读写实际的硬件设备，比如从键盘读入字符和把字符输出到显示器，线路规程(line discipline)像一个过滤器，对于某些特殊字符并不是让它直接通过，而是做特殊处理，比如在键盘上按下Ctrl-z，对应的字符并不会被用户程序的read读到，而是被线路规程截获，解释成SIGTSTP信号发给前台进程，通常会使该进程停止。线路规程应该过滤哪些字符和做哪些特殊处理是可以配置的。
ttyname函数
由文件描述符查出对应的文件名
#include <unistd.h>
char *ttyname(int fd); 成功：终端名；失败：NULL，设置errno
下面我们借助ttyname函数，通过实验看一下各种不同的终端所对应的设备文件名。
#include <unistd.h>
#include <stdio.h>
int main(void)
{
printf("fd 0: %s\n", ttyname(0));
printf("fd 1: %s\n", ttyname(1));
printf("fd 2: %s\n", ttyname(2));
return 0;
}
网络终端
虚拟终端或串口终端的数目是有限的，虚拟终端(字符控制终端)一般就是/dev/tty1∼/dev/tty6六个，串口终端的数目也不超过串口的数目。然而网络终端或图形终端窗口的数目却是不受限制的，这是通过伪终端（Pseudo TTY）实现的。一套伪终端由一个主设备（PTY Master）和一个从设备（PTY Slave）组成。主设备在概念上相当于键盘和显示器，只不过它不是真正的硬件而是一个内核模块，操作它的也不是用户而是另外一个进程。从设备和上面介绍的/dev/tty1这样的终端设备模块类似，只不过它的底层驱动程序不是访问硬件而是访问主设备。网络终端或图形终端窗口的Shell进程以及它启动的其它进程都会认为自己的控制终端是伪终端从设备，例如/dev/pts/0、/dev/pts/1等。下面以telnet为例说明网络登录和使用伪终端的过程。
TCP/IP协议栈：在数据包上添加报头。
如果telnet客户端和服务器之间的网络延迟较大，我们会观察到按下一个键之后要过几秒钟才能回显到屏幕上。这说明我们每按一个键telnet客户端都会立刻把该字符发送给服务器，然后这个字符经过伪终端主设备和从设备之后被Shell进程读取，同时回显到伪终端从设备，回显的字符再经过伪终端主设备、telnetd服务器和网络发回给telnet客户端，显示给用户看。也许你会觉得吃惊，但真的是这样：每按一个键都要在网络上走个来回！
进程组
概念和特性
进程组，也称之为作业。BSD于1980年前后向Unix中增加的一个新特性。代表一个或多个进程的集合。每个进程都属于一个进程组。在waitpid函数和kill函数的参数中都曾使用到。操作系统设计的进程组的概念，是为了简化对多个进程的管理。
当父进程，创建子进程的时候，默认子进程与父进程属于同一进程组。进程组ID=第一个进程ID(组长进程)。所以，组长进程标识：其进程组ID=其进程ID
可以使用kill -SIGKILL -进程组ID(负的)来将整个进程组内的进程全部杀死。
组长进程可以创建一个进程组，创建该进程组中的进程，然后终止。只要进程组中有一个进程存在，进程组就存在，与组长进程是否终止无关。
进程组生存期：进程组创建到最后一个进程离开(终止或转移到另一个进程组)。
一个进程可以为自己或子进程设置进程组ID
进程组操作函数
#include <unistd.h>
//getpgrp函数
获取当前进程的进程组ID
pid_t getpgrp(void); 总是返回调用者的进程组ID
//getpgid函数
获取指定进程的进程组ID
pid_t getpgid(pid_t pid); 成功：0；失败：-1，设置errno
如果pid = 0，那么该函数作用和getpgrp一样。
//setpgid函数
改变进程默认所属的进程组。通常可用来加入一个现有的进程组或创建一个新进程组。
int setpgid(pid_t pid, pid_t pgid); 成功：0；失败：-1，设置errno
将参1对应的进程，加入参2对应的进程组中。
注意：
1. 如改变子进程为新的组，应fork后，exec前。
2. 权级问题。非root进程只能改变自己创建的子进程，或有权限操作的进程
进程组操作函数例子
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
pid_t pid;
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
} else if (pid == 0) {
printf("child PID == %d\n",getpid());
printf("child Group ID == %d\n",getpgid(0)); // 返回组id
//printf("child Group ID == %d\n",getpgrp()); // 返回组id
sleep(7);
printf("----Group ID of child is changed to %d\n",getpgid(0));
exit(0);
} else if (pid > 0) {
sleep(1);
setpgid(pid,pid); //让子进程自立门户,成为进程组组长,以它的pid为进程组id
sleep(13);
printf("\n");
printf("parent PID == %d\n", getpid());
printf("parent's parent process PID == %d\n", getppid());
printf("parent Group ID == %d\n", getpgid(0));
sleep(5);
setpgid(getpid(),getppid()); // 改变父进程的组id为父进程的父进程
printf("\n----Group ID of parent is changed to %d\n",getpgid(0));
while(1);
}
return 0;
}
会话
会话：把多个进程组统一管理，形成会话
创建会话
创建一个会话需要注意以下6点注意事项：
1.调用进程不能是进程组组长，该进程变成新会话首进程(session header)
2.该进程成为一个新进程组的组长进程。
3.需有root权限(ubuntu不需要)
4.新会话丢弃原有的控制终端，该会话没有控制终端
5.该调用进程是组长进程，则出错返回
6.建立新会话时，先调用fork, 父进程终止，子进程调用setsid
getsid函数
获取进程所属的会话ID
#include <unistd.h>
pid_t getsid(pid_t pid); 成功：返回调用进程的会话ID；失败：-1，设置errno
pid为0表示察看当前进程session ID
ps ajx命令查看系统中的进程。参数a表示不仅列当前用户的进程，也列出所有其他用户的进程，参数x表示不仅列有控制终端的进程，也列出所有无控制终端的进程，参数j表示列出与作业控制相关的信息。
组长进程不能成为新会话首进程，新会话首进程必定会成为组长进程。
setsid函数
创建一个会话，并以自己的ID设置进程组ID，同时也是新会话的ID。
#include <unistd.h>
pid_t setsid(void); 成功：返回调用进程的会话ID；失败：-1，设置errno
调用了setsid函数的进程，既是新的会长，也是新的组长。
代码示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
pid_t pid;
if ((pid = fork())<0) {
perror("fork");
exit(1);
} else if (pid == 0) {
printf("child process PID is %d\n", getpid());
printf("Group ID of child is %d\n", getpgid(0));
printf("Session ID of child is %d\n", getsid(0));
sleep(10);
setsid(); //子进程非组长进程，故其成为新会话首进程，且成为组长进程。该进程组id即为会话进程
printf("Changed:\n");
printf("child process PID is %d\n", getpid());
printf("Group ID of child is %d\n", getpgid(0));
printf("Session ID of child is %d\n", getsid(0));
sleep(20);
exit(0);
}
return 0;
}
守护进程
Daemon(精灵)进程，是Linux中的后台服务进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以d结尾的名字。
Linux后台的一些系统服务进程，没有控制终端，不能直接和用户交互。不受用户登录、注销的影响，一直在运行着，他们都是守护进程。如：预读入缓输出机制的实现；ftp服务器；nfs服务器等。
创建守护进程，最关键的一步是调用setsid函数创建一个新的Session，并成为Session Leader。 为什么需要创建新的session？因为利用session的特性：session没有终端。
创建守护进程模型
1.创建子进程，父进程退出
所有工作在子进程中进行形式上脱离了控制终端
2.在子进程中创建新会话
setsid()函数
使子进程完全独立出来，脱离控制
3.改变当前目录为根目录
chdir()函数
防止占用可卸载的文件系统
也可以换成其它路径
4.重设文件权限掩码
umask()函数
防止继承的文件创建屏蔽字拒绝某些权限
增加守护进程灵活性
5.关闭文件描述符
继承的打开文件不会用到，浪费系统资源，无法卸载
6.开始执行守护进程核心工作
7.守护进程退出处理程序模型
创建守护进程示例
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
void mydaemond(void)
{
pid_t pid = fork();
if (pid > 0) {
exit(1);
}
setsid();
int ret = chdir("/home/ronghui/");
if (ret == -1) {
perror("chdir error"); // chdir error no such diractroy or file
exit(1);
}
umask(0022);
//close(fd[0]); //stdin
close(STDIN_FILENO);
open("/dev/null", O_RDWR);
dup2(0, STDOUT_FILENO);
dup2(0, STDERR_FILENO);
}
int main(void)
{
mydaemond();
while (1) {
}
return 0;
}
应用：每次机器重启，启动守护进程
修改bash shell配置（.bashrc），那么这个bash shell每次启动都会执行这个配置（.bashrc）里面的内容
# cd ~
# vi .bashrc
增加启动守护进程 如 .test_daemon
627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
