进程
虚拟内存与物理内存
概念
程序:编译好的可执行文件,存放在磁盘上的指令和数据的有序集合(文件),程序是静态的,没有任何执行的概念。
进程:一个独立的可调度任务,是执行一个程序所分配的资源的总称,是程序的一次执行过程,是动态的,包括创建、调度、执行 和 消亡。
特点
1、系统会为每一个进程分配 0-4G 的虚拟空间,【 虚拟空间 —mmap映射—> 物理空间 】
0-3G(用户空间)是每个进程所独有的,3G - 4G(内核空间)是所有进程共有的。
2、CPU 调度进程时 会给进程分配时间片(几毫秒 ~ 十几毫秒),
当时间片用完后,CPU 再进行其他进程的调度,实现进程的轮转,从而实现多任务的操作。
进程段(数据段、正文段、堆栈段)
Linux 中的进程包含三个段:
“数据段”存放 全局变量、常数以及动态数据分配的数据空间(如 malloc 函数取得的空间)等。
“正文段”存放 程序中的代码。
“堆栈段”存放 函数的返回地址、函数的参数以及程序中的局部变量。
进程分类
交互进程:
该类进程是由 shell 控制和运行的。交互进程既可以在前台运行,也可以在后台运行。
该类进程经常与用户进行交互,需要等待用户的输入,当接收到用户的输入后,该类进程会立刻响应。
典型的交互式进程有:shell命令进程、文本编辑器等。
批处理进程:
该类进程不属于某个终端,它被提交到一个队列中以便顺序执行。
守护进程:
该类进程在后台运行。它一般在 Linux 启动时开始执行,系统关闭时才结束。
进程状态
运行态(TASK_RUNNING):R
指正在被 CPU 运行或者就绪的状态。这样的进程被称为 running 进程。
睡眠态(等待态):S / D
可中断睡眠态(TASK_INTERRUPTIBLE)S:处于等待状态中的进程,一旦被该进程等待的资源被释
放,那么该进程就会进入运行状态。
不可中断睡眠态(TASK_UNINTERRUPTIBLE)D:该状态的进程只能用 wake_up() 函数 唤醒。
暂停态(TASK_STOPPED):T
当进程收到信号 SIGSTOP、SIGTSTP、SIGTTIN 或 SIGTTOU 时就会进入暂停状态。
可向其发送 SIGCONT 信号让进程转换到可运行状态。
死亡态:进程结束 X
僵尸态(TASK_ZOMBIE):Z
当进程已经终止运行,但还占用系统资源,要避免僵尸态的产生。
进程状态切换图
进程创建后,该进程进入就绪态,当 CPU 调度到此进程时,该进程进入运行态,
当时间片用完时,此进程会进入就绪态,如果此进程正在执行一些 IO操作(阻塞操作) 会进入阻塞态,
完成 IO操作(阻塞结束)后又可进入就绪态,等待 CPU 的调度,当进程运行结束即进入结束态。
函数
创建进程( fork )
pid_t fork(void);
功能:创建子进程
返回值:
成功:在父进程中:返回子进程的进程号 >0
在子进程中:返回值为 0
失败:-1,并设置 errno
#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
pid_t pid = fork(); // 此后的代码,子进程、父进程都会执行
if (pid < 0){
perror("Failed: ");
return -1;
} else if (pid == 0)
printf("I'm the child. \n");
else
printf("I'm the parent. \n");
return 0;
}
运行结果如下:
特点
1、子进程几乎拷贝了父进程的全部内容。包括代码、数据、系统数据段中的 pc值、栈中的数据、父进程中打开的文件等;但它们的 PID、PPID 是不同的。
2、父子进程有独立的地址空间,互不影响;
当在相应的进程中改变全局变量、静态变量,都互不影响。
3、若父进程先结束,子进程成为孤儿进程,被 init进程收养,子进程变成后台进程。
4、若子进程先结束,父进程如果没有及时回收,子进程变成僵尸进程。(要避免僵尸进程产生)
5、fork 之前的代码被复制,但不会被重新执行;fork 之后的代码会被复制,并且分别执行一遍。
#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
printf("Hello~ ");
fflush(NULL); // 若不加此句,则缓冲区被复制,子进程也会输出"hello"
pid_t pid = fork(); // fork 之后,缓冲区也被复制
// int var = 0;
if (pid < 0){
perror("Failed: ");
return -1;
} else if (pid == 0){
// var = 15;
printf("I'm the child. \n");
// while (1);
}
else{
printf("I'm the parent. \n");
}
return 0;
}
运行结果如下:
6、fork 之后两个进程彼此独立,子进程拷贝了父进程的所有代码,内存空间独立。
7、fork 之前打开文件,fork 之后拿到的是同一个文件描述符,操作的是同一个文件指针。
回收进程( wait、waitpid )
pid_t wait(int *status);
功能:回收子进程资源(阻塞父进程)
参数:status:子进程退出状态,不接受子进程状态可设为 NULL
返回值:成功:回收的子进程的进程号
失败:-1
pid_t waitpid(pid_t pid, int *status, int options);
功能:回收子进程资源
参数:
pid:>0 指定子进程进程号
=-1 任意子进程
=0 等待其组ID等于调用进程的组ID的任一子进程
<-1 等待其组ID等于pid的绝对值的任一子进程
status:子进程退出状态
options:0:阻塞
WNOHANG:非阻塞
返回值:正常:结束的子进程的进程号
当使用选项WNOHANG且没有子进程结束时:0
出错:-1
退出进程( exit、_exit )
void exit(int status);
功能:结束进程,刷新缓存
参数:退出的状态
不返回。
void _exit(int status);
功能:结束进程,不刷新缓存
参数:status 是一个整型的参数,可以利用这个参数传递进程结束时的状态。
通常 0 表示正常结束;
其他的数值表示出现了错误,进程非正常结束。
return 与 exit 的区别:
获取进程号( getpid、getppid )
pid_t getpid(void);
功能:获取当前进程的进程号
pid_t getppid(void);
功能:获取当前进程的父进程号
实现 cp 功能
通过父子进程完成对文件的拷贝(cp),
父进程从文件开始到文件的一半开始拷贝,子进程从文件的一半到文件末尾。
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
int main(int argc, char const *argv[])
{
int src = open(argv[1], O_RDONLY);
int dest = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0666);
if (src < 0 || dest < 0){
perror("Failed: ");
return -1;
}
off_t length = lseek(src, 0, SEEK_END);
pid_t pid = fork();
char buf[16] = {};
int num, count = 0;
if (pid < 0){
perror("Failed: ");
return -1;
} else if (pid > 0){
wait(NULL); // 先阻塞父进程, 等待子进程执行完毕后再执行父进程
lseek(src, 0, SEEK_SET);
lseek(dest, 0, SEEK_SET);
while ((num = read(src, buf, 16))!=0 && count < length / 2){
write(dest, buf, num);
count += 16;
}
} else {
lseek(src, length / 2, SEEK_SET);
lseek(dest, length / 2, SEEK_SET);
// lseek(src, 0, SEEK_CUR);
while ((num = read(src, buf, 16))!=0){
write(dest, buf, num);
}
}
close(src);
close(dest);
return 0;
}
exec 函数族
int execl(const char *path, const char *arg, ...
/* (char *) NULL */);
int execlp(const char *file, const char *arg, ...
/* (char *) NULL */);
int execle(const char *path, const char *arg, ...
/* (char *) NULL, char * const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],char *const envp[]);
守护进程
特点
1、守护进程是后台进程;
2、生命周期长(从系统启动时开启,系统关闭时结束);
3、脱离控制终端 且 周期执行的进程。
创建
1) 创建子进程,父进程退出;(子进程 —> 孤儿进程 —> 后台进程) fork(); exit(0);
2) 在子进程中创建新会话,让子进程成为会话组组长;(为了 让子进程完全脱离终端)setsid();
3) 改变进程运行路径为根目录;(保证 进程运行的路径不能被 删除或卸载) chdir(“/”);
4) 重设文件权限掩码;(增大进程创建文件时权限,提高灵活性) umask(0);
5) 关闭文件描述符;(将不需要的文件的文件描述符关闭) close();
1) 创建子进程,父进程退出;
// 子进程 —> 孤儿进程 —> 后台进程
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
pid_t pid = fork();
if (pid < 0){
perror("Failed: ");
return -1;
} else if (pid == 0){
while(1);
} else{
exit(0);
}
return 0;
}
2) 在子进程中创建新会话,让子进程成为会话组组长;
// 让子进程完全脱离终端
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
else if (pid == 0){
setsid();
while(1);
}
3) 改变进程运行路径为根目录;
// 保证 进程运行的路径不能被 删除或卸载
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
else if (pid == 0){
setsid();
chdir("/");
while(1);
}
4) 重设文件权限掩码;
// 增大进程创建文件时权限,提高灵活性
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
else if (pid == 0){
setsid();
chdir("/");
umask(0);
while(1);
}
5) 关闭文件描述符;
// 将不需要的文件的文件描述符关闭
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
else if (pid == 0){
setsid();
chdir("/");
umask(0);
for (int i = 0; i < 3; i++)
close(i);
while(1);
}
6) 创建成功
练习:循环间隔 1s 向文件中写入字符串“hello”
// 创建一个守护进程,循环间隔 1s 向文件中写入字符串“hello”
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char const *argv[])
{
int fd = open(argv[1], O_RDWR | O_CREAT | O_APPEND, 0666);
if (fd < 0){
perror("Failed: ");
return -1;
}
pid_t pid = fork();
if (pid < 0){
perror("Failed: ");
return -1;
} else if (pid == 0){
setsid();
chdir("/");
umask(0);
for (int i = 0; i < 3; i++)
close(i);
while(1){
write(fd, "Hello~\n", 7);
sleep(1);
}
} else {
exit(0);
}
close(fd);
return 0;
}