目录
一,程序的开始和结束
1、程序的开始
(1)main函数由编译链接时的引导代码调用。操作系统下的应用程序其实在main执行前也需要先执行一段引导代码才能去执行main,我们写应用程序时不用考虑引导代码的问题,编译连接时(准确说是连接时)由链接器将编译器中事先准备好的引导代码给连接进去和我们的应用程序一起构成最终的可执行程序。
(2)运行时的加载器。加载器是操作系统中的程序,当我们去执行一个程序时(譬如./a.out,譬如代码中用exec族函数来运行)加载器负责将这个程序加载到内存中去执行这个程序。
(3)程序在编译连接时用链接器,运行时用加载器,这两个东西对程序运行原理非常重要。
2、程序结束
(1)正常终止:return、exit、_exit
(2)非正常终止:自己或他人发信号终止进程
3、atexit注册进程终止处理函数
(1)实验代码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void func1(void)
{
printf("func1\n");
}
void func2(void)
{
printf("func2\n");
}
int main(void)
{
printf("hello world.\n");
// 当进程被正常终止时,系统会自动调用这里注册的func1执行
atexit(func2);
atexit(func1);
printf("test for atexit \n");
//return 0;
//exit(0);
_exit(0);
}
(2)atexit注册多个进程终止处理函数,先注册的后执行(先进后出,和栈一样)
(2)return、exit和_exit的区别:return和exit效果一样,都是会执行进程终止处理函数,但是用_exit终止进程时并不执行atexit注册的进程终止处理函数。
二,进程的引入
1、环境变量
(1)export命令查看环境变量
(2)进程环境表介绍.每一个进程中都有一份所有环境变量构成的一个表格,也就是说我们当前进程中可以直接使用这些环境变量。进程环境表其实是一个字符串数组,用environ变量指向它。
(3)程序中通过environ全局变量使用环境变量。
#include <stdio.h>
int main(void)
{
extern char **environ; // 声明就能用
int i = 0;
while (NULL != environ[i])
{
printf("%s\n", environ[i]);
i++;
}
return 0;
}
(4)我们写的程序中可以无条件直接使用系统中的环境变量,所以一旦程序中用到了环境变量那么程序就和操作系统环境有关了。
(4)获取指定环境变量函数getenv
2、进程运行的特点
(1)操作系统中每个进程在独立地址空间中运行
(2)每个进程的逻辑地址空间均为4GB(32位系统)
(3)0-1G为OS,1-4G为应用
(4)虚拟地址到物理地址空间的映射
(5)进程隔离,提供多进程同时运行
3、进程的定义
(1)动态过程而不是静态实物
(2)进程就是程序的一次运行过程,一个静态的可执行程序a.out的一次运行过程(./a.out去运行到结束)就是一个进程。
(3)进程控制块PCB(process control block),内核中专门用来管理一个进程的数据结构。
4、有关进程ID的API
(1)getpid、getppid、getuid、geteuid、getgid、getegid
简单举例getpid(获取进程的ID),getppid(获取进程的父进程):
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
pid_t p1 = -1, p2 = -1;
printf("hello.\n");
p1 = getpid(); //获取进程的ID号
printf("pid = %d.\n", p1);
p2 = getppid(); //获取进程的父进程
printf("parent id = %d.\n", p2);
return 0;
}
5、多进程调度的特点
(1)操作系统同时运行多个进程
(2)宏观上的并行和微观上的串行
(3)实际上现代操作系统最小的调度单元是线程而不是进程
三,父子进程
1.fork创建子进程
1、为什么要创建子进程
(1)每一次程序的运行都需要一个进程
(2)多进程实现宏观上的并行
2、fork的内部原理
(1)进程的分裂生长模式。如果操作系统需要一个新进程来运行一个程序,那么操作系统会用一个现有的进程来复制生成一个新进程。老进程叫父进程,复制生成的新进程叫子进程。子进程有自己独立的PCB子,被内核同等调度。
(2)fork的演示
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
pid_t p1 = -1;
p1 = fork(); // 返回2次
if (p1 == 0)
{
// 这里是子进程
printf("子进程, pid = %d.\n", getpid()); //打印子进程pid
printf("hello world.\n");
printf("子进程, 父进程ID = %d.\n", getppid()); //打印父进程pid
}
if (p1 > 0)
{
// 这里是父进程
printf("父进程, pid = %d.\n", getpid()); //打印父进程pid
printf("父进程, p1 = %d.\n", p1);
}
if (p1 < 0)
{
//出错
}
return 0;
}
(3)fork函数调用一次会返回2次,返回值等于0的就是子进程,而返回值大于0的就是父进程。
(4)典型的使用fork的方法:使用fork后然后用if判断返回值,并且返回值大于0时就是父进程,等于0时就是子进程。
(5)fork的返回值在子进程中等于0,在父进程中等于本次fork创建的子进程的进程ID。
2.父子进程对文件的操作
1、子进程继承父进程中打开的文件
(1)父进程先open打开一个文件得到fd,然后在fork创建子进程。之后在父子进程中各自write向fd中写入内容。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
int main(void)
{
// 首先打开一个文件
int fd = -1;
pid_t pid = -1;
fd = open("1.txt", O_RDWR | O_TRUNC);
if (fd < 0)
{
perror("open");
return -1;
}
// fork创建子进程
pid = fork();
if (pid > 0)
{
// 父进程中
printf("parent.\n");
write(fd, "hello", 5);
sleep(1);
}
else if (pid == 0)
{
// 子进程
printf("child.\n");
write(fd, "world", 5);
sleep(1);
}
else
{
perror("fork");
exit(-1);
}
close(fd);
return 0;
}
(2)测试结论是:接续写,打印出hello world。
实际上本质原因是父子进程之间的fd对应的文件指针是彼此关联的(很像O_APPEND标志后的样子)
2、父子进程各自独立打开同一文件实现共享
(1)父进程open打开1.txt然后写入,子进程打开1.txt然后写入。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
int main(void)
{
// 首先打开一个文件
int fd = -1;
pid_t pid = -1;
// fork创建子进程
pid = fork();
if (pid > 0)
{
// 父进程中
fd = open("1.txt", O_RDWR );
if (fd < 0)
{
perror("open");
return -1;
}
printf("parent.\n");
write(fd, "hello", 5);
sleep(1);
}
else if (pid == 0)
{
// 子进程
fd = open("1.txt", O_RDWR );
if (fd < 0)
{
perror("open");
return -1;
}
printf("child.\n");
write(fd, "world", 5);
sleep(1);
}
else
{
perror("fork");
exit(-1);
}
close(fd);
return 0;
}
结论是:分别写。
原因是父子进程分离后才各自打开的1.txt,这时候这两个进程的PCB已经独立了,文件表也独立了,因此2次读写是完全独立的。
(2)open时使用O_APPEND标志看看会如何?实际测试结果标明O_APPEND标志可以把父子进程各自独立打开的fd的文件指针给关联起来,接续写。
3、总结
(1)父子进程间终究多了一些牵绊
(2)父进程在没有fork之前自己做的事情对子进程有很大影响,但是父进程fork之后在自己的if里做的事情就对子进程没有影响了。本质原因就是因为fork内部实际上已经复制父进程的PCB生成了一个新的子进程,并且fork返回时子进程已经完全和父进程脱离并且独立被OS调度执行。
(2)子进程最终目的是要独立去运行另外的程序
3.进程的诞生和消亡
1、进程的诞生
(1)进程0和进程1
(2)fork
(3)vfork
2、进程的消亡
(1)正常终止和异常终止
(2)进程在运行时需要消耗系统资源(内存、IO),进程终止时理应完全释放这些资源(如果进程消亡后仍然没有释放相应资源则这些资源就丢失了)
(3)linux系统设计时规定:每一个进程退出时,操作系统会自动回收这个进程涉及到的所有的资源(譬如malloc申请的内容没有free时,当前进程结束时这个内存会被释放,譬如open打开的文件没有close的在程序终止时也会被关闭)。但是操作系统只是回收了这个进程工作时消耗的内存和IO,而并没有回收这个进程本身占用的内存(8KB,主要是task_struct和栈内存)
(4)因为进程本身的8KB内存操作系统不能回收需要别人来辅助回收,因此我们每个进程都需要一个帮助它收尸的人,这个人就是这个进程的父进程。
3、僵尸进程
(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”,在这一段(子进程已经结束且父进程尚未帮其收尸)子进程就被成为僵尸进程
(2)子进程除task_struct和栈外其余内存空间皆已清理
(3)父进程可以使用wait或waitpid以显式回收子进程的剩余待回收内存资源并且获取子进程退出状态。
(4)父进程也可以不使用wait或者waitpid回收子进程,此时父进程结束时一样会回收子进程的剩余待回收内存资源。(这样设计是为了防止父进程忘记显式调用wait/waitpid来回收子进程从而造成内存泄漏)
4、孤儿进程
(1)父进程先于子进程结束,子进程成为一个孤儿进程。
(2)linux系统规定:所有的孤儿进程都自动成为一个特殊进程(进程1,也就是init进程)的子进程。
4.父进程wait回收子进程
wait函数介绍
1、wait的工作原理
父进程调用wait函数后阻塞,子进程结束时,系统向其父进程发送SIGCHILD信号,父进程被SIGCHILD信号唤醒然后去回收僵尸子进程,若父进程没有任何子进程则wait返回错误。父子进程之间是异步的,SIGCHILD信号机制就是为了解决父子进程之间的异步通信问题,让父进程可以及时的去回收僵尸子进程。
2、wait实战编程
(1)wait的参数status。status用来返回子进程结束时的状态,父进程通过wait得到status后就可以知道子进程的一些结束状态信息。
(2)wait的返回值pid_t,这个返回值就是本次wait回收的子进程的PID。当前进程有可能有多个子进程,wait函数阻塞直到其中一个子进程结束wait就会返回,wait的返回值就可以用来判断到底是哪一个子进程本次被回收了。
(3)WIFEXITED、WIFSIGNALED、WEXITSTATUS这几个宏用来获取子进程的退出状态。
WIFEXITED宏用来判断子进程是否正常终止(return、exit、_exit退出)
WIFSIGNALED宏用来判断子进程是否非正常终止(被信号所终止)
WEXITSTATUS宏用来得到正常终止情况下的进程返回值的
对wait做个总结:wait主要是用来回收子进程资源,回收同时还可以得知被回收子进程的pid和退出状态。
(4)fork后wait回收实例
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
int main(void)
{
pid_t pid = -1;
pid_t ret = -1;
int status = -1;
pid = fork();
if (pid > 0)
{
// 父进程
printf("parent.\n");
ret = wait(&status);
printf("子进程已经被回收,子进程pid = %d.\n", ret);
printf("子进程是否正常退出:%d\n", WIFEXITED(status));
printf("子进程是否非正常退出:%d\n", WIFSIGNALED(status));
printf("正常终止的终止值是:%d.\n", WEXITSTATUS(status));
}
else if (pid == 0)
{
// 子进程
printf("child pid = %d.\n", getpid());
return 51;
//exit(0);
}
else
{
perror("fork");
return -1;
}
return 0;
}
waitpid介绍
1、waitpid和wait差别
(1)基本功能一样,都是用来回收子进程
(2)waitpid可以回收指定PID的子进程
(3)waitpid可以阻塞式或非阻塞式两种工作模式
2、效果分析
(1)使用waitpid实现wait的效果ret = waitpid(-1, &status, 0);
-1表示不等待某个特定PID的子进程而是回收任意一个子进程,0表示用默认的方式(阻塞式)来进行等待,返回值ret是本次回收的子进程的PID
(2)ret = waitpid(pid, &status, 0);
等待回收PID为pid的这个子进程,如果当前进程并没有一个ID号为pid的子进程,则返回值为-1;如果成功回收了pid这个子进程则返回值为回收的进程的PID
(3)ret = waitpid(pid, &status, WNOHANG);
这种表示父进程要非阻塞式的回收子进程。此时如果父进程执行waitpid时子进程已经先结束等待回收则waitpid直接回收成功,返回值是回收的子进程的PID;如果父进程waitpid时,子进程尚未结束则父进程立刻返回(非阻塞),但是返回值为0(表示回收不成功)。
3、竟态初步引入
(1)竟态全称是:竞争状态,多进程环境下,多个进程同时抢占系统资源(内存、CPU、文件IO)
(2)竞争状态对OS来说是很危险的,此时OS如果没处理好就会造成结果不确定。
(3)写程序当然不希望程序运行的结果不确定,所以我们写程序时要尽量消灭竞争状态。操作系统给我们提供了一系列的消灭竟态的机制,我们需要做的是在合适的地方使用合适的方法来消灭竟态。
5.exec族函数及实战
1、为什么需要exec函数
(1)fork子进程是为了执行新程序(fork创建了子进程后,子进程和父进程同时被OS调度执行,因此子进程可以单独的执行一个程序,这个程序宏观上将会和父进程程序同时进行)
(2)可以直接在子进程的if中写入新程序的代码。这样可以,但是不够灵活,因为我们只能把子进程程序的源代码贴过来执行(必须知道源代码,而且源代码太长了也不好控制),譬如说我们希望子进程来执行ls -la 命令就不行了(没有源代码,只有编译好的可执行程序)
(3)使用exec族函数运行新的可执行程序(exec族函数可以直接把一个编译好的可执行程序直接加载运行)
(4)我们有了exec族函数后,我们典型的父子进程程序是这样的:子进程需要运行的程序被单独编写、单独编译连接成一个可执行程序,主程序为父进程,fork创建了子进程后在子进程中exec来执行一个可执行程序,达到父子进程分别做不同程序同时(宏观上)运行的效果。
2、exec族的6个函数介绍
(1)execl和execv
这两个函数是最基本的exec,都可以用来执行一个程序,区别是传参的格式不同。execl是把参数列表(本质上是多个字符串,必须以NULL结尾)依次排列而成(l其实就是list的缩写),execv是把参数列表事先放入一个字符串数组中,再把这个字符串数组传给execv函数。
(2)execlp和execvp
这两个函数在上面2个基础上加了p,区别是:上面2个执行程序时必须指定可执行程序的全路径(如果exec没有找到path这个文件则直接报错),而加了p的传递的可以是file(也可以是path,只不过兼容了file。加了p的这两个函数会首先去找file,如果找到则执行执行,如果没找到则会去环境变量PATH所指定的目录下去找,如果找到则执行如果没找到则报错)
(3)execle和execvpe
这两个函数较基本exec来说加了e,函数的参数列表中也多了一个字符串数组envp形参,e就是environment环境变量的意思,和基本版本的exec的区别就是:执行可执行程序时会多传一个环境变量的字符串数组给待执行的程序。
3、exec实战
(1)使用execl和execv运行ls -l -a
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
int main(void)
{
pid_t pid = -1;
pid_t ret = -1;
int status = -1;
pid = fork();
if (pid > 0)
{
// 父进程
printf("parent, 子进程id = %d.\n", pid);
}
else if (pid == 0)
{
// 子进程
execl("/bin/ls", "ls", "-l", "-a", NULL); // execl函数
//char * const arg[] = {"ls", "-l", "-a", NULL}; //execv函数
//execv("/bin/ls", arg);
return 0;
}
else
{
perror("fork");
return -1;
}
return 0;
}
(2)使用execl运行自己写的程序
先自己写一个简单的hello world程序,然后gcc hello.c -o hello,把hello.c编译成hello可执行程序。
hello.c
#include <stdio.h>
int main(int argc, char **argv)
{
int i = 0;
printf("argc = %d.\n", argc);
while (NULL != argv[i])
{
printf("argv[%d] = %s\n", i, argv[i]);
i++;
}
return 0;
}
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
int main(void)
{
pid_t pid = -1;
pid_t ret = -1;
int status = -1;
pid = fork();
if (pid > 0)
{
// 父进程
printf("parent, 子进程id = %d.\n", pid);
}
else if (pid == 0)
{
// 子进程
execl("hello", "aaa", "bbb", NULL); //使用execl函数
//char * const arg[] = {"aaa", "bbb", NULL}; //使用execv函数
//execv("hello", arg);
return 0;
}
else
{
perror("fork");
return -1;
}
return 0;
}
4、execlp和execvp
(1)加p和不加p的区别是:不加p时需要全部路径+文件名,如果找不到就报错了。加了p之后会先帮我们到PATH所指定的路径下去找,再到当前目录找。
execlp("ls", "ls", "-l", "-a", NULL);
5、execle和execvpe
(1)main函数的原型其实不止是int main(int argc, char **argv),
而可以是int main(int argc, char **argv, char **env)
第三个参数是一个字符串数组,内容是环境变量。
(2)如果用户在执行这个程序时没有传递第三个参数,则程序会自动从父进程继承一份环境变量(默认的,最早来源于OS中的环境变量);如果我们exec的时候使用execlp或者execvpe去给传一个envp数组,则程序中的实际环境变量是我们传递的这一份(取代了默认的从父进程继承来的那一份)
char * const envp[] = {"AA=aaaa", "XX=abcd", NULL};
execle("hello", "hello", "-l", "-a", NULL, envp);