Linux系统编程(一) --进程基础

1 基础

ps -u skx u 查看当前系统中属于skx用户（有效用户 id）的进程，最后那个 u 表示以用户格式显示。

$ ps -u skx u
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
skx        1698  0.0  0.1  77292  3584 ?        Ss   9月19   0:12 /lib/systemd/systemd --user
skx        1699  0.0  0.0 261764   180 ?        S    9月19   0:00 (sd-pam)
skx        1713  0.0  0.1 283304  2488 ?        Sl   9月19   0:00 /usr/bin/gnome-keyring-daemon
skx       32611  0.2  0.2  24872  5536 pts/0    Ss   22:48   0:00 bash

各字段含义

名称	含义
USER	进程的属主
PID	进程的 id 号
%CPU	进程占用的 CPU 百分比
%MEM	占用的内存百分比
VSZ	进程虚拟大小
RSS	驻留页的数量
TTY	终端 id 号
STAT	进程状态（D、R、S、T、W、X、Z、<、N、L、s 等）
START	进程开始运行时间
TIME	累积使用的CPU时间
COMMAND	使用的命令

进程位于内存里，是有状态的，进程状态值的含义如下：

D 不可中断睡眠 R 运行或就绪态 S 休眠状态 T 停止或被追踪

W 进入内存交换（从内核2.6开始无效） X 死掉的进程 Z 僵尸进程

< 优先级高的进程 N 优先级较低的进程

L 有些页被锁进内存 s 进程的领导者（在它之下有子进程）

getpid 查看当前进程的 id， getppid 查看父进程 id。

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

int main() {
	pid_t pid = getpid();
	pid_t ppid = getppid();
	printf("Process ID : %d\n", pid);
	printf("Parent process ID : %d\n", ppid);
	sleep(3);
	return 0;
}

$ gcc getmyid.c -o getmyid
$ ./getmyid 
Process ID:32740
Parent process ID: 32611

进程 32611号是终端 pts/1 中的 bash 进程，而这个进程恰恰又是 getmyid 进程的父进程，这不是巧合，因为我刚刚在 pts/1 终端中键入了./getmyid ，这时 pts/1 中的 bash 进程生出了进程 32740号进程 ./getmyid 。

2 fork函数

pid_t fork(void);

返回值是 pid_t 类型，是 typedef 定义的32位有符号整型数。

调用一次，返回两次，父进程返回子进程id（>0），子进程返回0，失败返回-1。

// myfork.c
#include<unistd.h>
#include<stdio.h>
#include<string.h>


int main(){
	char buf[] = "Hello, I'm father\n";
	write(STDOUT_FILENO, buf, strlen(buf));
	printf("before fork\n");
	
	pid_t pid = fork();
	
	if(!pid){
		printf("I'm child %d; my father is %d\n", getpid(), getppid());
		sleep(2);
	}
	else if(pid > 0){
		printf("I'm father %d; my child is %d\n", getpid(), pid);
		sleep(2);
	}
	else{
		perror("fork");
		return 1;
	}
	return 0;
}

$ gcc myfork.c -o myfork
$ ./myfork 
Hello, I'm father
.before fork
I'm father 32884; my child is 32885
I'd child 32885; my father is 32884

它把结果重定向到了 tmp 文件中，打开你的 tmp 文件看看吧！

$ ./myfork > tmp
$ cat tmp 
Hello, I'm father
before fork
I'm father 33384; my child is 33385
before fork
I'm child 33385; my father is 33384

tmp 文件里的 before fork 出现两次

原因：

当 printf 接收到字符串后，把字符串复制到一个 char 数组（缓冲区）中，当数组遇到了特定的字符，比如 ‘\n’ 字符，回车或者装满等等，就会立即把字符写到屏幕终端上。而把 printf 重定向到文件时，如果 printf 函数遇到 ‘\n’ 字符，并不会立即把字符写到文件里，这是 printf 函数将字符定向到屏幕和文件的重要区别。所以当 ./myfork > tmp 这个进程执行到 fork 时，printf 里的缓冲区数据还没来得及被刷新到 tmp 文件里，就被 fork 函数复制了，同时，printf 的缓冲区也被复制了一模一样的一份出来。

3 进程空间

3.1 进程地址互不影响

实验：有个经典的 C 语言的例子，就是进程 A 中往地址 0x50000000 写入一个 int 类型的整数 100，然后在进程 B 的地址0x50000000 写入另一个 int 类型的整数 1000，最后两个进程再各自通过 printf 函数打印这两个地址保存的值，发现进程 A 仍然可以正常打印 100，而进程 B 正常打印出 1000。

在windows 系统下运行（因为 linux 不直接提供在指定地址上分配内存的函数）

• 进程 A 的代码

#include <windows.h>
#include<stdio.h>

int main()
{
    int* buf = (int*)0x50000000;
    LPVOID res = VirtualAlloc((LPVOID)buf, sizeof(int), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
    if (res != buf) {
        printf("ERROR!\n");
        return 1;
    }

    *buf = 100;

    printf("A = %d\n", *buf);

    Sleep(3000);
    return 0;
}

• 进程 B 的代码

#include <windows.h>
#include<stdio.h>

int main()
{
    int* buf = (int*)0x50000000;
    LPVOID res = VirtualAlloc((LPVOID)buf, sizeof(int), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
    if (res != buf) {
        printf("ERROR!\n");
        return 1;
    }

    *buf = 1000;

    printf("B = %d\n", *buf);

    Sleep(3000);
    return 0;
}

结论：进程空间就是进程虚拟地址空间。不同进程的地址空间是隔离的，在相同的地址写不同的值，互不影响。

两进程在相同位置写，互不影响

3.2 虚拟地址到物理地址的映射

对于进程来说，属于进程地址是虚拟的。这中间有一步到物理地址的映射过程。

物理地址图两进程虚拟地址映射

每个进程认为自己有 4GB 的虚拟地址，如果物理空间不够，系统把一部分不经常用的数据放硬盘上。

虚拟地址空间与物理地址之间的映射关系保存在页表中。

3.3 fork函数原理

1、创建一个子进程

2、把父进程的数据复制到新创建的子进程中。

fork两步操作，1、创建进程，2、复制数据

为什么子进程的 fork函数返回 0？

fork 就是将进程的地址空间复制一份，复制完后，操作系统直接把它赋值为 0。

3.4 写时复制技术

fork执行时，数据没有复制，读时共享 ，写时复制

需要写土豆数据，复制一份

4 fork函数与文件共享

实进程空间被分割为用户空间和内核空间。对于32 位 linux 来说，从 0-3GB 的空间是用户空间，从 3GB - 4GB 是内核空间。对于一个进程来说，是绝对无法读写内核空间的。进程的用户空间是隔离的，而内核空间是共享的。

进程的用户空间和内核空间

进程所有打开的描述符，都会有记录。记录保存该进程的 PCB 结构体中（PCB位于内核空间），该结构体的成员 struct file *flip[NR_OPEN] 保存了所有打开的文件。

进程打开的文件

struct file 结构体中的 f_inode 并不是真的直接指向磁盘文件，这中间有若干步骤。

进程 fork 后，变成下面这个样子。struct file 中的 f_count 都会自增1。父子进程共享 struct file 结构（该结构位于内核空间）。struct file 称为文件表。

fork 后父进程和子进程之间对打开文件的共享

实验：在 fork 之前以写的方式创建了一个文件 test.txt。然后 fork 出的子进程立即向文件中写入"world"，然后睡眠5秒。而父进程在 fork 后睡眠3秒后向 test.txt 写入 “hello”，并关闭描述符。子进程恢复后，又向 test.txt 文件中写入 "lalala"后关闭描述符，结束。

// forkwrite.c
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    int fd = open("test.txt", O_WRONLY | O_CREAT, 0664);
    if (fd == -1) {
        perror("open");
        return 1;
    }
    printf("I'm father\n");
    printf("before fork\n");

    pid_t pid = fork();
    if (pid > 0) {
        sleep(3);
        printf("I'm father; I'm writing test.txt...\n");
        write(fd, "hello", 5);
        close(fd);
    }
    else if (pid == 0) {
        printf("I'm child; I'm writing test.txt...\n");
        write(fd, "world", 5);
        sleep(5);
        write(fd, "lalala", 6);
        close(fd);
    }
    else {
        perror("fork");
        return 1;
    }
    return 0;
}

$ ./forkwrite 
I'm father
before fork
I'm child; I'm writing test.txt...
I'm father; I'm writing test.txt...
$ cat test.txt 
worldhellolalala

可以看到文件是共享的。

fork 后父进程和子进程之间对打开文件的共享

除打开的文件外，父进程的很多其他性质也会被子进程共享，比如各种 ID 号、当前工作目录、根目录、资源的限制、信号屏蔽字、进程环境、文件打开执行时关闭标志、共享存储段。

5 exec 系列函数与进程空间结构

5.1 exec系列函数

exec 系列函数的目的：把本进程空间的代码和数据全部替换成你指定的数据，然后从新程序的入口点开始执行。该进程执行的程序完全代替为新程序，新程序从其main函数开始执行，因为调用exec并不创建新进程，所以前后ID并不改变。exec只是用磁盘上的一个新程序代替了当前进程中的正文段，数据段，堆段和栈段。这里只介绍其中一个execvp。

区别1：带p的取文件名做参数（filename中有/，视为路径，否则用PATH环境变量寻找可执行文件），不带p取路径名，最后一个取文件描述符

区别2：参数传递，l表示列表，v表示矢量vector

区别3：像新程序传递环境变量，以e结尾的传递环境变量参数，其他使用当前环境。

实验：使用 execvp 启动 ls 命令

#include <unistd.h>
#include <string.h>
#include <stdio.h>

int main() {
    char* argv[] = { "ls", "-l", NULL }; // 构造 vector，注意argv[0] 是占用参数
    if (execvp("ls", argv) == -1) { // 替换代码段和数据段，并重新从 ls 入口点执行
        perror("exec");
        return 1;
    }

    return 0;
}

运行结果和使用 ls -l 命令一模一样。

函数名中字母含义

p：以filename作为参数，并且用PATH环境变量寻找可执行文件

l：表示 list，表示函数参数是可变参数，与v互斥

v：代表 vector，表示参数是数组。

e：表示函数需要传递环境变量参数，不使用当前环境。

exec 系列函数，只有 execve 才是真正的系统调用接口，其它的 5 个函数都是标准 C 函数库中的函数，最终都调用了 execve 这个函数。

5.2 进程空间结构

进程空间结构

exec 系列函数的本质就是替换代码段和数据段，然后从新的入口点重新执行。对应到图中，就是替换整个粉红色的区域。使用 execvp 函数本质上就是进程执行到 execvp 的时候，要执行文件的二进制文件读取出来，替换掉代码段和数据段，同时 execvp 函数会把 BSS 段重新清 0。

5.3 exec + fork

父进程正常运行，子进程执行别的命令。

有了 fork 的出现，exec 才真正体现出它的强大。咱们完全可以把 exec 放到子进程中去。

实验：

// forkandexec.c
#include <unistd.h>
#include <string.h>
#include <stdio.h>

int main() {
    char* argv[] = { "ls", "-l", NULL };
    pid_t pid = fork();

    if (pid > 0) {
        printf("I'm father\n");
    }
    else if (pid == 0) {
        printf("I'm child\n");
        if (execvp("ls", argv) == -1) {
            perror("exec");
            return 1;
        }
    }
    else {
        perror("fork");
        return 0;
    }
    return 0;
}

$ ./forkandexec 
I'm father
I'm child
$ 总用量 16
-rwxr-xr-x 1 skx skx 8488 9月  25 10:51 forkandexec
-rw-r--r-- 1 skx skx  342 9月  25 10:51 forkandexec.c

vfork 采用了类似读时共享的机制，但是其不保证写时复制，它产生的子进程和父进程共享进程空间，所以，如果在 vfork 后没有使用 exec 或者 _exit 函数，其行为将是未定义的。

6 wait和waitpid

6.1 僵尸进程

子进程运行结束，父进程还没有，就会产生僵尸进程。父进程还没结束，子进程先死了（发送 SIGCHILD信号给父进程），父进程对它视而不见。只要子进程状态发生改变都会给父进程发信号(SIGCHLD)。

实验：造几个僵尸进程

// mywait.c
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main() {
    printf("before fork\n");

    pid_t pid, n = 5;

    // 父进程生出 5 个子进程
    while (n--) {
        pid = fork();
        if (pid == 0) break;
        else if (pid < 0) {
            perror("fork");
            return 1;
        }
    }

    // 子进程打印一句话就死了。
    if (pid == 0) {
        printf("hello, I'm child %d; my father is %d\n", getpid(), getppid());
        return 0;
    }

    // 父进程永远在这打印。
    while (1) {
        sleep(3);
        printf("hello, I'm father %d\n", getpid());
    }
    return 0;
}

$ gcc mywait.c -o mywait
$ ./mywait 
before fork
hello, I'm child 34140; my father is 34139
hello, I'm child 34141; my father is 34139
hello, I'm child 34144; my father is 34139
hello, I'm child 34143; my father is 34139
hello, I'm child 34142; my father is 34139
hello, I'm father 34139
hello, I'm father 34139
...

查看僵尸进程

$ ps -ef | grep mywait
skx       34139  32611  0 20:48 pts/0    00:00:00 ./mywait
skx       34140  34139  0 20:48 pts/0    00:00:00 [mywait] <defunct>
skx       34141  34139  0 20:48 pts/0    00:00:00 [mywait] <defunct>
skx       34142  34139  0 20:48 pts/0    00:00:00 [mywait] <defunct>
skx       34143  34139  0 20:48 pts/0    00:00:00 [mywait] <defunct>
skx       34144  34139  0 20:48 pts/0    00:00:00 [mywait] <defunct>
skx       34146  34090  0 20:48 pts/1    00:00:00 grep --color=auto mywait

可以看到，这里有 5 个进程，名字被加了方括号，后面还跟着 <defunct> 字样。

实际上，子进程在死的时候，通知了它父亲（发送 SIGCHILD信号给父进程）父进程未理睬。除非子进程的父亲也死了，这时候会有 init 进程来替代原来的父亲替这些子进程收尸。

6.2 wait清理僵尸进程

僵尸进程越来越多，最后就会造成资源耗尽。

wait 函数原型如下：

pid_t wait(int *status);

参数保存子进程退出通知码，返回 -1 表示没有子进程或者错误。否则返回子进程的进程 id 号。

// wipeoutzombie.c
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/types.h>

int main() {
    printf("before fork\n");

    pid_t pid, n = 5;
    while (n--) {
        pid = fork();
        if (pid == 0) break;
        else if (pid < 0) {
            perror("fork");
            return 1;
        }
    }

    if (pid == 0) {
        printf("hello, I'm child %d; my father is %d\n", getpid(), getppid());
        return 0;
    }


    while (1) {
        sleep(3);
        pid = wait(NULL); // 忽略子进程通知码
        if (pid == -1) {
            perror("wait");
            sleep(10);
            printf("I'm father %d; I have wiped out all zombies\n", getpid());
            return 1;
        }
        printf("Hello, I'm father %d; child %d exit\n", getpid(), pid);
    }
    return 0;
}

$ gcc wipeoutzombie.c -o wipeoutzombie
$ ./wipeoutzombie 
before fork
hello, I'm child 34212; my father is 34211
hello, I'm child 34216; my father is 34211
hello, I'm child 34214; my father is 34211
hello, I'm child 34213; my father is 34211
hello, I'm child 34215; my father is 34211
Hello, I'm father 34211; child 34212 exit
Hello, I'm father 34211; child 34213 exit
Hello, I'm father 34211; child 34214 exit
Hello, I'm father 34211; child 34215 exit
Hello, I'm father 34211; child 34216 exit
wait: No child processes
I'm father 34211; I have wiped out all zombies

6.3 waitpid

作用：waitpid 函数和 wait 函数都是用来获取子进程的状态。

pid_t waitpid(pid_t pid, int *status, int options);

调用 wait(&status)相当于调用 waitpid(-1, &status, 0)。

参数 pid

pid > 0，表示 waitpid 只等待子进程 pid。

pid = 0，表示 waitpid 等待和当前调用 waitpid 一个组的所有子进程。

pid = -1，表示等待所有子进程。

pid < -1，表示等组 id=|pid|（绝对值 pid）的所有子进程。

参数status

status 描述的是子进程的退出状态。通过宏来判断。status 分成下面四类：

• 1 进程正常退出：WIFEXITED(status)
• 2 进程被信号终止：WIFSIGNALED(status)
• 3 进程被暂停执行：WIFSTOPPED(status)
• 4 进程被恢复执行：WIFCONTINUED(status)

1、如果 WIFEXITED(status)返回true，进程正常退出。可以使用WEXITSTATUS(status)来获取进程的退出码（main 函数的 return 值或者 exit 函数的参数值）。

2、如果WIFSIGNALED(status) 返回 true，进程被信号终止。可以通过宏 WTERMSIG(status) 获取子进程被哪种信号终止。

3、如果 WIFSTOPPED(status) 返回 true，进程收到信号暂停执行。可以通过宏 WSTOPSIG(status)获取子进程被哪个信号暂停。这时可以通过宏 WCOREDUMP(status) 返回 true 还是 false 来判断是否生生了 core 文件。

4、如果 WIFCONTINUED(status) 返回 true，进程收到信号SIGCONT恢复执行。

参数 options

参数 options 是可个组合选项。可以任意使用位或 | 运算符自由组合他们。如果 options 置空意味着 waitpid 函数是阻塞的。三个可组合选项如下：

• WNOHANG (设置非阻塞，即使子进程全部正常运行，waitpid 也会立即返回 0)
• WUNTRACED (可获取子进程暂停状态，也就是可获取 stopped 状态)
• WCONTINUED (可获取子进程恢复执行的状态，也就是可获取 continued 状态)

返回值

waitpid 的返回值会有 > 0,，= 0，= -1。

• = −1意味着没有子进程或者其它错误。
• = 0，只有在打开了 WNOHANG 的情况下才会可能出现。如果子进程都是正常运行没有发生状态改变，它就会返回 0。
• > 0，只要有任意一个子进程状态发生改变，比如停止，终止，恢复执行，waitpid 返回该子进程的 pid。

实验：

// wipeoutzombie2.c
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/types.h>

int main() {
    printf("before fork\n");

    // 生成 5 个子进程
    pid_t pid, n = 5;
    while (n--) {
        pid = fork();
        if (pid == 0) break;
        else if (pid < 0) {
            perror("fork");
            return 1;
        }
    }

    // 每个子进程一生出来就睡眠 4*n + 1 秒，不要问为什么是 4*n + 1，这只是我随便写的，只想保证每个子进程睡眠时间不一样。
    if (pid == 0) {
        sleep(4 * n + 1);
        printf("hello, I'm child [ %d ]; my father is [ %d ]\n\n", getpid(), getppid());

        // 这一句，我故意让这个子进程 core 掉，主要用来看效果。
        if (4 * n + 1 == 5) *((int*)0) = 0;

        // 子进程再退出的时候，返回它的睡眠时间
        return 4 * n + 1;
    }


    int status = 0;
    while (1) {
        // 这里 waitpid 接收所有子进程状态，但是没有打开 WNOHANG 开关，同学们可以自行加上看看效果
        pid = waitpid(-1, &status, WUNTRACED | WCONTINUED);

        // 出错情况，这种一般是子进程全部结束了。
        if (pid == -1) {
            perror("wait");
            sleep(5);
            printf("I'm father [ %d ]; I have wiped out all zombies\n\n", getpid());
            return 1;
        }
        // 这种只会在 WNOHANG 开关打开的情况下出现
        else if (pid == 0) {
            printf("Hello, I'm father; I'm waiting child\n\n");
        }
        // 这种是只要有一个子进程状态发生改变就会进来。注意 4 类情况，比较多。  
        else {

            if (WIFEXITED(status)) {
                printf("child [ %d ] <exited> with code [ %d ]\n\n", pid, WEXITSTATUS(status));
            }
            else if (WIFSIGNALED(status)) {
                printf("child [ %d ] <terminated> abnormally, signal [ %d ]\n\n", pid, WTERMSIG(status));
#ifdef WCOREDUMP
                if (WCOREDUMP(status)) {
                    printf("<core file generated> in child [ %d ]\n\n", pid);
                }
#endif
            }
            else if (WIFSTOPPED(status)) {
                printf("child [ %d ] <stopped>, signal [ %d ]\n\n", pid, WSTOPSIG(status));
            }
            else if (WIFCONTINUED(status)) {
                printf("child [ %d ] <continued>\n\n", pid);
            }
        }

    }
    return 0;
}

$ gcc wipeoutzombie2.c -o wipeoutzombie2
$ ./wipeoutzombie2
before fork
hello, I'm child [ 34327 ]; my father is [ 34322 ]

child [ 34327 ] <exited> with code [ 1 ]

hello, I'm child [ 34326 ]; my father is [ 34322 ]

child [ 34326 ] <terminated> abnormally, signal [ 11 ]

<core file generated> in child [ 34326 ]

hello, I'm child [ 34325 ]; my father is [ 34322 ]

child [ 34325 ] <exited> with code [ 9 ]

hello, I'm child [ 34324 ]; my father is [ 34322 ]

child [ 34324 ] <exited> with code [ 13 ]

hello, I'm child [ 34323 ]; my father is [ 34322 ]

child [ 34323 ] <exited> with code [ 17 ]

wait: No child processes
I'm father [ 34322 ]; I have wiped out all zombies

6.4 core 文件

由于各种异常或者bug导致程序运行过程中异常退出或者中止，在满足一定条件下会产生一个叫做core的文件。

7 kill命令

kill -9 2008，表示发送信号 9 给进程 2008。

那么当你执行 ./wipeoutzombie2 的时候，你可以通过 kill 发送信号给子进程，看看屏幕打印的情况的变化。