文章目录
- 一、进程状态
- （二）进程状态切换实例
- 1. 实例1
- 二、进程的创建
- （一）原理
- （二）fork函数--创建进程
- 1. 定义
- 2. 不关注返回值
- 3. 关注返回值
- （三） 父子进程的执行顺序
- （四）父子进程内存空间
- （五）使用实例
- 三、 getpid/getppid
- 四、孤儿进程
- 五、僵尸进程
- 三、进程退出exit/_exit函数
- （一）exit
- （二）_exit
- 四、进程回收资源
- （一）wait
- （二）waitpid
一、进程状态
可通过 man ps 查看
R (runing or runnable) 运行态或者可被运行态(在运行队列中)
S (interruptible sleep) 可被中断的休眠态
D (uninterruptible sleep) 不可被中断的休眠态
T (stopped by job control signal) 停止态
Z (("zombie") process)僵尸态
X (dead ) 死亡态（永远不会被看到）
I (Idle kernel thread) 空闲内核线程
进程的附加状态：
< 高优先级的进程
N 低优先级的进程
s (session leader)会话组组长
l (multi-threaded)进程中包含多线程
+ 前台进程组的进程
L 有页在内存中被锁定
（二）进程状态切换实例
1. 实例1
#include <stdio.h>
int main(int argc, char const *argv[])
{
int i=0;
while(1){
printf("%d\n",i++);
sleep(1);
}
return 0;
}
① 该程序运行时，大部分时间在休眠，处于休眠态
./a.out 运行 ------ 前台运行
② 想让一个进程在后台运行
可以 在运行进程的命令后面加一个 & 如 ./a.out &
- 注：
- 前台运行时，终端会被该进程占用，无法继续接收命令
- 后台运行时，终端会被释放出来，可以接收命令
- 处于后台运行时，无法直接“CTRL+C”来结束进程，需要发送
kill -19 pid
③可以使用 kill -19 pid 给进程发19号信号让进程停止（T停止态）
也可以使用 ctrl+z 来停止进程(相当于给进程发kill -20 pid)
在被停止的进程的终端上使用 jobs -l 可以查看进程的作业号
- 注：此处必须在被停止的进程的终端上查看，其他终端无法查看
fg 作业号 让停止的进程继续在前台运行
bg 作业号 让停止的进程继续在后台运行
kill -18 pid 让停止的进程继续在后台运行
二、进程的创建
（一）原理
进程的创建是通过 完全 拷贝父进程来实现的，子进程所有资源都来自于父进程。
子进程创建成功后，父子进程的执行相互独立
（二）fork函数–创建进程
1. 定义
#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
功能：拷贝父进程，产生子进程
参数：无
返回值：
成功 给父进程返回子进程的PID 给子进程返回 0
失败 -1 不会创建子进程 会重置错误码
2. 不关注返回值
在不考虑返回值时，调用n次fork函数，会产生2^n个进程（包含父进程）
#include <my_head.h>
int main(int argc, char const *argv[])
{
for(int i=0;i<2;i++){
fork();
printf("#");
}
return 0;
}
输出结果：
分析结果：
要注意此处printf中并没有\n，即打印的’#‘存放在输出缓冲区中，而在循环第二次执行时，fork函数通过拷贝父进程生成子进程，即将其缓冲区也进行了拷贝，因此打印出了8个’#’
#include <my_head.h>
int main(int argc, char const *argv[])
{
for(int i=0;i<2;i++){
fork();
printf("#\n");
}
return 0;
}
输出结果：
分析结果：
要注意此处printf中有\n，此时的’#‘直接打印到了终端上，而在循环第二次执行时，fork函数通过拷贝父进程生成子进程，其缓冲区内是空的，直接又各自执行了一次打印操作，因此打印出了6个’#’
3. 关注返回值
fork函数给父进程返回子进程的pid，给子进程返回0，因此通过pid进行条件判断。
pid>0，说明当前进程是父进程；pid==0，说明当前进程是子进程，由此来使其执行各自的程序。
#include <my_head.h>
int main(int argc, char const *argv[])
{
printf("-----start-----\n");
pid_t pid=fork();
if(-1 == pid){
ERR_LOG("fork error");
}else if(0 < pid){
printf("这是父进程\n");
}else if(0 == pid){
printf("这是子进程\n");
}
printf("-----end-----\n");
return 0;
}
（三） 父子进程的执行顺序
父子进程执行，没有先后顺序，也是时间片轮转，谁得到cpu谁执行
（四）父子进程内存空间
父进程在fork产生子进程时，用到了写时拷贝的原则
如果父子进程中如果都只对同一个变量有读操作，那么不会重新映射到不同的物理内存；
只有在父子进程的中的任意一方执行了写操作时，才会重新映射到不同的物理内存
（五）使用实例
功能需求：使用父子进程拷贝文件，提高拷贝效率
因为cpu在执行程序时是按照时间片轮转的方式，哪个进程得到cpu就在这个时间片执行程序，而使用父子进程同时拷贝，就相当于增加了时间片轮转轮到的概率，由此提高拷贝效率。
需求分析：
fork之前打开的文件，fork之后，父子访问文件时是共用光标的。
如果不想让光标共用，可以在fork之后，父子进程中分别使用open去打开文件。
将源文件和目标文件一分为二，父进程复制文件开头到中间的位置的内容，子进程复制文件中间位置到结尾的内容，两个进程分别打开文件，不共用文件标识符
- 补充：关于可否使用父子进程在打开的文件中共用光标来实现拷贝的可实现性：
不能保证在一个时间片段内可以完整的执行完一条机器指令；因此可能会出现以下情况，如父进程读取了一段内容后，准备执行光标后移，但是未完成光标后移时就发生了时间片轮转，接着子进程再次复制时，光标并未移动，而重复读取内容。
代码实现：
#include <my_head.h>
int main(int argc, char const *argv[])
{
if(3 != argc){
printf("Usage:%s src dest\n",argv[0]);
exit(-1);
}
//获取文件大小
struct stat file_stat;
if(-1 == stat(argv[1],&file_stat))
ERR_LOG("stat error");
int size = file_stat.st_size;
char buff[10]={0};
int nbyte=0;
int w_byte=0;
//创建子进程
pid_t pid=fork();
if(-1==pid){
ERR_LOG("fork error");
}else if(0 < pid){//父进程
//打开文件，从文件开头
int src_fd = open(argv[1],O_RDONLY);
int dest_fd = open(argv[2],O_WRONLY|O_CREAT,0666);
//复制
while(0 < (nbyte = read(src_fd,buff,sizeof(buff)))){
write(dest_fd,buff,nbyte);
//判断是不是写了一半
w_byte=w_byte+nbyte;
if(w_byte >= size/2) break;
}
//关闭文件
close(src_fd);
close(dest_fd);
sleep(1);//等待子进程结束
}else if(0 == pid){//子进程
//打开文件，从文件中间
int src_fd = open(argv[1],O_RDONLY);
lseek(src_fd,size/2,SEEK_SET);
int dest_fd = open(argv[2],O_WRONLY|O_CREAT,0666);
lseek(dest_fd,size/2,SEEK_SET);
//复制
while(0 < (nbyte = read(src_fd,buff,sizeof(buff)))){
write(dest_fd,buff,nbyte);
}
//关闭文件
close(src_fd);
close(dest_fd);
}
return 0;
}
三、 getpid/getppid
#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);
功能：返回调用进程的pid
参数：无
返回值：总是会成功
pid_t getppid(void);
功能：返回调用进程的父进程pid
参数：无
返回值：总是会成功
eg：使用fork创建进程，A创建B，B创建C，在每个进程中打印pid和ppid。
#include <my_head.h>
int main(int argc, const char *argv[])
{
pid_t pid = fork();
if(-1 == pid){
ERR_LOG("fork error");
}else if(0 < pid){
sleep(3);
printf("我是A pid = [%d] ppid = [%d]\n", getpid(), getppid());
}else if(0 == pid){
if(-1 == (pid = fork())){
ERR_LOG("fork error");
}else if(0 < pid){
sleep(1);
printf("我是B pid = [%d] ppid = [%d]\n", getpid(), getppid());
}else if(0 == pid){
printf("我是C pid = [%d] ppid = [%d]\n", getpid(), getppid());
}
}
return 0;
}
四、孤儿进程
子进程还没有执行完，父进程就结束了，此时子进程就是孤儿进程
孤儿进程会被 init 进程收养，当孤儿进程结束时 init 给他回收资源
孤儿进程就是一个正常的进程，当只不过其父进程变成了init。
他并不是进程状态的一种。
五、僵尸进程
当子进程运行结束后，父进程没有为其回收资源，此时子进程就是僵尸进程
僵尸进程对系统有害，占着资源不释放
三、进程退出exit/_exit函数
（一）exit
- 注：
- return 本身不使用来结束进程的，而是用来结束函数调用的，
- 只有在main函数中执行到return 才会结束整个进程 而在子函数中实行return只会结束函数调用
#include <stdlib.h>
void exit(int status);
功能：他是一个库函数，用来结束进程，他会刷新缓冲区
参数：status：给父进程返回的进程退出状态值 (0-255)
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
返回值：无
（二）_exit
#include <unistd.h>
void _exit(int status);
功能：他是一个系统调用，用来结束进程，他不会刷新缓冲区
参数：status：给父进程返回的进程退出状态值
返回值：无
四、进程回收资源
（一）wait
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *wstatus);
功能：
wait用于父进程中，用来阻塞等待任意一个子进程退出，给子进程回收资源
子进程exit退出时的状态值 会被wait接收到。
参数：
wstatus：用来保存子进程退出状态的缓冲区的首地址
如果不关心子进程退出的状态 可以传 NULL
如果使用了：
0-6：7个bit位中保存的是终止子进程的信号的编号
8-15： 8个bit位保存的是子进程退出的状态值
WIFEXITED(wstatus) 如果为真 说明子进程是正常结束的
WEXITSTATUS(wstatus) 如果子进程是正常结束的 可以用它获取子进程退出的状态值
WIFSIGNALED(wstatus) 如果为真 说明子进程是被信号中断的
WTERMSIG(wstatus) 如果子进程是被信号中断的 可以使用它来获取终止子进程的信号的编号
返回值：
成功 终止的子进程的pid
失败 -1 重置错误码
（二）waitpid
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);
功能：
等待指定pid的子进程退出，为其回收资源
参数：
pid：要回收资源的子进程的pid
>0 回收指定pid的子进程的资源
-1 回收任意一个子进程的资源
0 回收和父进程同组的任意一个子进程的资源
<-1 回收任意一个进程组id等于 pid 的绝对值的子进程的资源
wstatus：和wait用法一样
options：标志位 0 阻塞 WNOHANG 非阻塞
返回值：
成功 回收资源的子进程的pid
如果设置了 WNOHANG 且没有子进程退出时 返回 0
失败 -1 重置错误码
注：
有下面等价的用法：
wait(NULL) <==> waitpid(-1, NULL, 0);
wait(&wstatus) <==> waitpid(-1, &wstatus, 0);
