Linux操作系统----进程2
文章目录
-
- 环境变量
- 程序地址空间
- 再度理解fork（）函数
- 进程退出的场景
- 进程等待
- 进程程序替换
- minishell
环境变量
指令，可执行程序本质都是文件（Linux下基本上神马都是文件），为什么一个要./呢（指明是当前路径）？ 一个直接输入就可以直接执行呢？
就是因为环境变量（这里起作用的环境变量是PATH）。 它帮指令找到对应的路径，我们自己生成的可执行成程序要手动指明对应的路径。
所以可以这样理解环境变量：操作系统在内存中开辟的空间，用来保存系统相关的数据，为了指定操作系统的运行环境。
- echo: 显示某个环境变量值
- export: 设置一个新的环境变量
- env: 显示所有环境变量
- unset: 清除环境变量
- set: 显示本地定义的shell变量和环境变量
如何获取环境变量呢？
1 #include #include 环境变量通常是具有全局属性的
环境变量通常具有全局属性，可以被子进程继承下去
程序地址空间
看看代码
#include 输出结果：parent[g_val=100] &g_val = 0x601044
child[g_val=10] &g_val = 0x601044
说明：变量内容不一样，说明肯定不上同一个变量，但是地址却相同，说明地址不是物理地址，是虚拟地址
在Linux地址下，这种地址叫做 虚拟地地址我们在用C/C++语言所看到的地址，全部都是虚拟地址，
物理地址，用户一概看不到，由OS统一管理
每个进程在运行的时候都会创建属于自己的进程控制块，地址空间，页表，，，等等。
进程这样去访问物理内存有什么作用呢？地址空间存在的意义是说明呢？ 为什么不让进程直接去访问物理内存呢？？？
1，通过添加一层软件层，对进程操作物理内存进行风险管理（也就是权限管理，是页表的功能），为了保护物理内存
和进程的数据安全。
2，将内存使用和内存申请在时间上可以隔开，通过虚拟地址屏蔽掉底层的内存申请过程，达到进程读写内存和OS进行内存
管理进行分离开来。
3，在CPU和应用层的角度，进程统一可以看作使用4GB的空间，（也就是进程认为自己独占CPU资源），而且每个虚拟地址空间
的各个位置非常明确。
再度理解fork（）函数
#include fork（）也就是创建了子进程，给子进程返回0，给父进程返回子进程pid，创建失败返回 < 0。
创建失败的原因可能有：系统中有太多的进程，实际用户的进程数超过了限制。
为什么子进程没有执行那句话呢？ ：fork（）之前，父进程单独运行，fork（）之后，子进程只会去执行fork（）之后的代码。
父子进程的执行顺序由调度器确定，没有明确的规定
写时拷贝的核心：
进程退出的场景
我们知道，进程退出的时候，会有退出码的。也无非是这3种情况
1，代码运行完毕，结果正确。 返回0
2，代码运行完毕，结果不正确。 返回 非0
3，异常终止，程序崩溃。 这时候的退出码无意义，需要退出信号。
exit，_exit,return 其实三者在main函数的时候没有多少区别。
但是惟独_exit是直接退出，不做人任何收尾工作，例如：刷新缓冲区，执行用户定义的清理函数，，，、、、
进程等待
首先，为什么要进程等待呢？
1，我们知道，子进程的资源是需要父进程去释放的。如果父进程不管不顾，子进程就会成为僵尸进程，造成内存泄露
2，父进程创建子进程，需要知道子进程的执行结果，如果不等待，又如何知道子进程的状态和执行结果呢
3，父进程必须通过等待的方式对子进程的资源进行回收释放
关于等待函数wait和waitpid
什么是阻塞等待，什么又是非阻塞等待呢？举个列子：
在一个月黑风高的夜晚，你要和你的女朋友小方去操场散步，你已经在小方的宿舍楼下，小方说自己要化妆，要一会时间。
你在那里啥也不干，只是抬头看着宿舍大门，看小方来了没有。这就是阻塞等待。
如果你在那里一边嗑瓜子，每过两分钟就打电话问一下小方来了没有。这就是非阻塞等待。
int main
{
pid_t pid;
9 int ret,st;
10 if ( (pid=fork()) == -1 )
11 perror("fork"),exit(1);
12 if ( pid == 0 )
13 {
14 printf("child pid :%d\n",getpid());
15 sleep(40);
16 exit(10);
17 }
18 else
19 {
20 ret = wait(&st); //wait默认的就是阻塞等待
21 }
22
23 if ( ret > 0 && ( st & 0X7F ) == 0 )
24 { // 正常退出
25 printf("child exit code:%d\n", (st>>8)&0XFF); //运行完毕后的正常退出
26 }
27 else if( ret > 0 )
28 { // 异常退出
29 printf("sig code : %d\n", st&0X7F ); //在其他终端杀掉会返回 9
30 }
31
32 return 0;
33 }
阻塞等待
int main()
{
pid_t pid;
pid = fork();
if (pid < 0)
{
printf("%s fork error\n", __FUNCTION__);
return 1;
}
else if (pid == 0)
{ //child
printf("child is run, pid is : %d\n", getpid());
sleep(5);
exit(-1);
}
else
{
int status = 0;
pid_t ret = waitpid(-1, &status, 0);//0阻塞式等待，等待5S ，而-1表示等待任意一个子进程，和wait一样
printf("this is test for wait\n");
if (WIFEXITED(status) && ret == pid)
{
printf("wait child 5s success, child return code is :%d.\n", WEXITSTATUS(status));
}
else
{
printf("wait child failed, return.\n");
return 1;
}
}
return 0;
}
非阻塞等待：
int main()
8 {
9 pid_t pid;
10 pid = fork();
11 if(pid < 0)
12 {
13 printf("%s fork error\n",__FUNCTION__);
14 return 1;
15 }
16 else if( pid == 0 )
17 {
//child
18 printf("child is run, pid is : %d\n",getpid());
19 sleep(5);
20 exit(1);
21 }
22 else
23 {
24 int status = 0;
25 pid_t ret = 0;
26 do
27 {
28 ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
29 if( ret == 0 )
30 {
31 printf("child is running\n");
32 }
33 sleep(1);
}while(ret == 0); //非阻塞等待方式就是一直去询问子进程是否退出，没有退出返回0
35
36 if( WIFEXITED(status) && ret == pid )
37 {
38 printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
39 }
40 else
41 {
42 printf("wait child failed, return.\n");
43 return 1;
44 }
45 }
46 return 0;
47 }
进程程序替换
什么是程序替换呢？
仅仅替换当前进程的代码和数据（实际上并不创建新的进程）
替换原理：
用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数
以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动
例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。
替换函数一共有6种
#include 函数解析：
这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
如果调用出错则返回-1
所以exec函数只有出错的返回值而没有成功的返回值
l(list) : 表示参数采用列表传指令（在命令行上如何操作就如何去传）
v(vector) : 参数用数组 的方式去传参数列表指令
p(path) : 有p自动搜索环境变量PATH
e(env) : 表示自己维护环境变量，传给将要替换后执行的进程。
这个是myexec.c文件
int main()
7 {
8
9 if(fork() == 0)
10 {
11
12 // char* argv[] = {"ls","-a","-l",NULL};
13 //execl("/usr/bin/ls","ls","-a","-l",NULL); // 这个是用命令参数列表传
14 // execlp("ls","ls","-a","-l",NULL); //这个是指明环境变量路径
15 //execv("/usr/bin/ls",argv); //以指针数组的方式去传递指令
16 //execvp("ls",argv); // 以数组方式传参，并且指明环境变量路径
17
18 char* argv[] = {"./mylode",NULL};
19 char* env[] = {"myenv = hello chen ",NULL};
20 //execve("./mylode",argv,env); //这个是传递环境变量给替换执行后的进程
21 execle("./mylode","./myldoe",NULL,env);
22 printf("hello chen\n");
23 }
24
25 waitpid(-1,NULL,0);
26 printf("parent wait end\n");
27 return 0;
28 }
29
mylode.c文件
#include makefile:
1 .PHONY:all //make 自动搜索第一个依赖关系
2 all:myexec mylode //all 依赖于 myexec mylode，且没有依赖方法
3
4 myexec:myexec.c //而myexec又依赖于myexec.c，有依赖方法会去执行方法
5 gcc -o $@ $^ -std=c99
6
7 mylode:mylode.c
8 gcc -o $@ $^ -std=c99
9
10 .PHONY:clean //.PHONY 伪目标，总是可被执行的
11 clean:
12 rm -f mylode myexec
~
另外的一个点就是上面的所有进程替换函数种，只有execve是系统调用，其他的本质上都会去调用它。
minishell
用一个自己做的minishell来对之前的知识进行回顾复习。
int main()
55 {
56 char commond[100] = {0};
57
58 while(1)
59 {
60 //1,从命令行中读取字符串
61 commond[0] = '\0'; //以O(1)清空字符串
62 printf("[who@mylinuxrobtname mydir]$ ");
63 fgets(commond,100,stdin); //从标准输入读取，一定会读到'\n'
64 commond[strlen(commond)-1] = 0; //处理一下'\n'
65 fflush(stdout); //清空缓存区
66
67 //2，解析命令
68 char* argv[100];
69 char* sep = " ";//以空格为分隔符
70 argv[0] = strtok(commond,sep); //第一次切割字符传的时候会记录切割位置，下一次传NULL
71 int i = 1;
72 while(argv[i] = strtok(NULL,sep))
73 i++;
74
75
76 //这个可以检测一下输入的命令是否正确
77 // for(i = 0; argv[i]; i++)
78 // {
79 // printf("%s\n",argv[i]);
80 // }
81 //
82
//fork()子进程只能执行第三方独立程序，例如ls，ll都是第三方指令
//而cd .. 要回退上级路径，是当前子进程做不到的，所以要让父进程自己执行，去调用父进程的函数
//chdir（）可改变路径
83 if(strcmp(argv[0],"cd") == 0) //假设输入 cd ..
84 {
85 if(argv[1] != NULL)
86 {
87 chdir(argv[1]); // chdir是回退上级路径 ..
88 }
89 continue;
90 }
91
92
93
94
95 if(fork() == 0)
96 {
97 //子进程
98 execvp(argv[0],argv); //进程替换
99 }
100
101 int status = 0;
102 int ret = waitpid(-1,&status,0);
103 //if(ret > 0 && WIFEXITED(status))
//{
105 // printf("exit sucsess %d",WEXITSTATUS(status));
106 //}
107 //else
108 //{
109 // printf("sigal exit %d",status & 0x7F);
110 //}
111 //
112
113 }
114
115 return 0;
116 }