fork 进程复制 父子进程共享文件偏移量 exec替换进程

最新推荐文章于 2023-05-16 20:07:43 发布
最新推荐文章于 2023-05-16 20:07:43 发布
阅读量557 收藏 4
点赞数 4
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45888512/article/details/120978330
版权

printf函数以及缓冲区

在这里插入图片描述
先打印hello 在睡眠3s钟

去掉 \n 之后 先睡眠3s在打印hello
在这里插入图片描述
正常认知:代码是顺序执行 printf执行完后才能执行sleep. 由于缓冲区的作用,退出程序才把缓冲去的内容显示到了屏幕上.

打印的内容是如何显示到屏幕上的

当有以下三种情况时,缓冲区才会把数据传输到标准输出设备(显示器)中进行输出
1.缓冲区满
2.程序结束时
3.强制刷新缓冲区 “\n” fflush(stdout)可以达到此效果
缓冲区的内容提交给内核 利用write()打印到屏幕上

fork()复制进程

进程:一个正在运行的程序

内核把进程存放在叫做任务队列(task list)的双向循环链表中。链表中的每一项都是类型为task_struct、称为进程描述符(process descriptor)的结构，该结构定于在<linux/sched.h>文件中。进程描述符中包含一个具体进程的所有信息。

fork 函数会新生成一个进程，调用 fork 函数的进程为父进程，新生成的进程为子进程。
在父进程中返回子进程的 pid，在子进程中返回 0，失败返回-1。

一个理解fork()小例子

#include<stdio.h>
#include<stdlib.h> 
#include<unistd.h>
#include<string.h>
#include<assert.h>
int main() {
	int n = 0;
    char* s = NULL;
	pid_t id = fork();//复制进程
	assert(id != -1);
	if (id == 0) {//子进程
		n = 3;
		s = "child";
	}
	else {//父进程
		n = 7;
		s = "parent";
	}
	//子进程和父进程打印次数分别为3、7
	for (int i = 0; i < n; ++i) {
		printf("s=%s,pid=%d\n",s,getpid());
		sleep(1);
	}
	exit(0);
}

在这里插入图片描述
在这里插入图片描述

父进程先于子进程结束
修改 n 的次数也就相当于修改了子进程以及父进程执行for()的次数
在这里插入图片描述
在这里插入图片描述

fork笔试题
1.

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
 int main(){
   fork()||fork();
   printf("A\n");
   exit(0); 
  }

在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
 int main(){
   fork()&&fork();
   printf("A\n");
   exit(0); 
  }

在这里插入图片描述
在这里插入图片描述

 #include<stdio.h>
 #include<unistd.h>
 #include<stdlib.h>
 int main(){    
 for(int i=0;i<2;++i){
      fork();
      printf("A\n");
  }
    exit(0); 
}

在这里插入图片描述
在这里插入图片描述

4.去掉3中的\n

 #include<stdio.h>
 #include<unistd.h>
 #include<stdlib.h>
 int main(){    
 for(int i=0;i<2;++i){
      fork();
      printf("A");
  }
    exit(0); 
}

在这里插入图片描述
在这里插入图片描述

父进程先终止
系统保证每个进程都有一个父进程，若父进程比子进程先终止，则该父进程的所有子进程的父进程都改变为init进程。我们称这些进程由init进程领养。其执行顺序大致如下:在一个进程终止时，内核逐个检查所有活动的进程，以判断它是否是正要终止的进程的子进程，如果是，则该进程的父进程ID就更改为1(init进程的ID)。

僵死进程及处理方法

(1) 僵死进程概念：子进程先于父进程结束，父进程没有调用 wait 获取子进程退出码。
(2)僵死进程的危害:如果父进程不调用wait()/waitpid()的话,那么存在于那个位置的信息就不会被释放,它的PCB就会被永远占用,但是系统的进程表的容量是有限的,所能使用的进程号也是有限的,所以如果产生了大量的僵死进程,将因为没有可用的进程而导致系统不能产生新的进程,也就无法fork()；所以,僵死进程不仅占用系统的内存信息,还影响了系统的性能,如果大量产生,还会导致系统瘫痪.
(3) 如何处理僵死进程：父进程通过调用 wait()完成。
(4) Init 进程收养孤儿进程

#include<stdio.h>
#include<stdlib.h> 
#include<unistd.h>
#include<string.h>
#include<assert.h>
int main() {
	int n = 0;
    char* s = NULL;
	pid_t id = fork();//复制进程
	assert(id != -1);
	if (id == 0) {//子进程
		n = 3;
		s = "child";
	}
	else {//父进程
		n = 7;
		s = "parent";
	}
	//子进程和父进程打印次数分别为3、7
	for (int i = 0; i < n; ++i) {
		printf("s=%s,pid=%d\n",s,getpid());
		sleep(1);
	}
	exit(0);
}

在这里插入图片描述

父进程通过调用 wait()获取子进程的退出码解决了僵死进程

#include<stdio.h>
#include<stdlib.h> 
#include<unistd.h>
#include<string.h>
#include<assert.h>
#include<sys/wait.h>
int main() {
	int n = 0;
    char* s = NULL;
	pid_t id = fork();//复制进程
	assert(id != -1);
	if (id == 0) {//子进程
		n = 3;
		s = "child";
	}
	else {//父进程
		n = 7;
		s = "parent";
		int val=0;
		wait(&val);
		printf("val=%d\n",val);
	}
	//子进程和父进程打印次数分别为3、7
	for (int i = 0; i < n; ++i) {
		printf("s=%s,pid=%d\n",s,getpid());
		sleep(1);
	}
	exit(0);
}

pid_t wait(int *status); *status 是子进程的结束状态值(exit(0)中的 0 在系统中会通过左移8位显示出),返回值为子进程PID.
如果子进程没结束那么wait会阻塞
在这里插入图片描述
在这里插入图片描述
从上图可以看到子进程结束后，彻底从系统中消失，并没有变成僵死进程.

*int wait(int status) 函数的宏

1.WIFEXITED(status)这个宏用来指出子进程是否为正常退出的,如果是,它会返回一个非零值。(此处status是个整数).
2.WEXITSTATUS(status)当WITEXITED返回非零值时,我们可以用这个宏来提取子进程的返回值,如果子进程调用exit(3)退出,WEXITSTATUS(status)就会返回3;如果子进程调用exit(4)退出,WEXITSTATUS(status)就会返回4.如果进程不是正常退出,也就是说,WIFEXITED返回0,这个值就毫无意义.

#include<stdio.h>
#include<stdlib.h> 
#include<unistd.h>
#include<string.h>
#include<assert.h>
#include<sys/wait.h>
int main() {
	int n = 0;
    char* s = NULL;
	pid_t id = fork();//复制进程
	assert(id != -1);
	if (id == 0) {//子进程
		n = 3;
		s = "child";
	}
	else {//父进程
		n = 7;
		s = "parent";
		int val=0;
		int id=wait(&val);
		if(WIFEXITED(val)){
		printf("id=%d,val=%d\n",id,WEXITSTATUS(val));
		}		
	}
	//子进程和父进程打印次数分别为3、7
	for (int i = 0; i < n; ++i) {
		printf("s=%s,pid=%d\n",s,getpid());
		sleep(1);
	}
	exit(0);
}

在这里插入图片描述

操作文件的系统调用:open,read,write,close 返回值为文件描述符(int)

open read write close 系统调用,实现在内核中

PCB(进程描述符\进程控制块)用struct task_struct;实现.文件描述符表是此结构体的成员
在这里插入图片描述

每次打开文件(open操作时 )，会产生struct file这样一个结构体在操作系统内核中，用来表示打开的这个文件，记录着文件偏移量（起始从0开始，随着写入数据进行增加），引用计数（使用此文件的进程个数），inode节点（存放进程的属性信息：创建者，存储信息。通过inode节点，能找到对应的文件）

1.先打开文件在复制进程(先open在fork)

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>

int main(){

     int fd=open("file1.txt",O_RDONLY);//abcdef
     assert(fd!=-1);

     pid_t pid=fork();
     assert(pid!=-1);

     if(pid==0){//子进程
    //每次读一个字符并输出
     char buff[8]={0};
     read(fd,buff,1);
     printf("child buff=%s\n",buff);
     sleep(1);
     read(fd,buff,1);
     printf("child buff=%s\n",buff);
     }
    else{//父进程
      //每次读一个字符并输出
       char buff[8]={0};
       read(fd,buff,1);
       printf("parent buff=%s\n",buff);
       sleep(1);
       read(fd,buff,1);
       printf("parent buff=%s\n",buff);
    }
    close(fd);
    exit(0);
 }

运行结果在这里插入图片描述

结论:子进程可以使用fork之前open返回的文件描述符。调用fork之后，只拷贝了PCB本身，拷贝的只是指针，没有拷贝指针所指向的内容，这种情况叫做浅拷贝。子进程的指针依旧指向struct file,所以父子进程对于文件描述符和文件偏移量是共享的。

在这里插入图片描述
此时父子进程共享此文件的属性,引用计数==2，父子进程都执行close()才可以彻底关闭文件.

2.先复制进程在打开文件(先fork在open)

在这里插入图片描述
在这里插入图片描述
父子进程各自打开各自的文件
示意图如下:在这里插入图片描述

替换进程

进程的产生:fork+exec
exec函数作用:把当前进程替换为一个新进程，且新进程与原进程有相同的PID.并从新程序的main第一行开始执行.替换成功,原程序就会被替换为新程序,并执行新程序.
exec系列

int execl(const char *pathname, const char arg, … / (char *) NULL */);
int execlp(const char *file, const char arg, … / (char *) NULL */);
int execle(const char *pathname, const char arg, …/, (char *) NULL, char *const envp[] */);
int execv(const char *pathname, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);
函数返回值: 成功不返回，失败返回-1.

分为两大类:execl()系列和execv()系列
path参数表示你要启动程序的名称包括路径名
l:list要求将新进程的每个命令行参数都说名为一个单独的参数，以空指针结尾.
v: 是指把所有参数放到容器(数组, vector)中再一次性传入.
p: 是指第1个参数位于默认的环境变量PATH中,忽略pathname,仅用文件(file)指出文件名即可.
e:是指第1个参数位于给定的envp环境变量中., 用绝对路径(path)给出待执行文件.

使用ps替换main

execl()
在这里插入图片描述
在这里插入图片描述
替换之后进程name是ps,替换后的进程的pid和main的pid相同,这说明替换进程并不改变原有pid.

其它execl系列的使用(只列出了较上面程序不同的部分)

*****可以不用给全路径只给命令名字 
execlp("ps","ps","-f",(char*)NULL);
//有e需要环境变量
execle("/usr/bin/ps","ps","-f",(char*)NULL,envp);

execv系列
在这里插入图片描述
在这里插入图片描述

其它execv系列的使用(只列出了较上面程序不同的部分)

***可以不用给全路径只给命令名字 
execvp("ps",myargv);
***有p可以只给命令名字
execvpe("ps",myargv,envp);
//有e需要环境变量
execve("/usr/bin/ps",myargv,envp);
心向光明呀
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fork函数详解与进程替换（exec）
Eunice_fan1207的博客
08-10 2533
&lt;1&gt;fork定义 一个现有进程可以调用fork函数创建一个新进程。由fork创建的新进程被称为子进程（child process）。fork函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。 我们经常说fork后的子进程相当于是子进程的一个克隆，fork出来的父子进程并行fork之后的代码，但是子进程真的是完全复制了父进程吗？答案是不，那么到...
多进程 fork之后父子进程 对文件描述符的作用
u013378057的专栏
01-03 503
#include  #include  #include #include  #include #include          int main()  { int fd = open("data",O_WRONLY | O_CREAT, 0777);  int pid = -1; int stat; if(fd == -1) { printf("文件打开
父子进程拷贝文件
09-01
linux C语言，编程实现父子进程同时拷贝文件，各复制一半
linux下的fork()函数
Zayn的博客
11-06 471
linux下fork函数的理解 正文说明： 第一次在CSDN上写博客，请各位方家多多指正，其中的精髓是参考一位很优秀博主的博客， 原文链接：link 本人在读了之后有醍醐灌顶之感，于是决定自己再回顾重写一遍。 正文如下： C语言代码实例: #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;string.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt;
fork复制进程
XXXTENTAC1ON的博客
11-26 516
进程的描述 进程是一个正在运行的程序 每个进程都有一个进程控制块，英文缩写PCB 进程控制块是一个用结构体struct task_struct来实现 操作系统如何管理进程 进程控制块是进程存在的唯一标志，pid是一个整型，它属于是进程的身份证号码，由于pid是由整型表示的，所以pid的范围也就是一个整型的大小范围 fork复制进程 首先会将原来的进程（父进程）PCB复制一块出来，并且给他申请一个pid，来唯一标识子进程，接下来将整个进程的实体复制一份给子进程 复制出来的子进程与父进程是相同的，唯一不
第八章：Linux进程复制fork与替换
hi332516_1的博客
05-12 248
文章目录八、Linux进程复制与替换1 printf函数输出问题2 主函数参数介绍3 复制进程fork3.1 fork方法3.2 fork练习4 僵死进程及处理方法 八、Linux进程复制与替换 1 printf函数输出问题   printf函数并不会直接将数据输出到屏幕，而是先放到缓冲区中，只有以下三种情况满足，才会输出到屏幕。   1）缓冲区满   2）强制刷新缓冲区 fflush   3）程序结束时 2 主函数参数介绍 int main(int argc, char* argv[], char* en
Linux 进程替换(exec函数）实现代码
09-15
总结来说，`exec`函数家族在Linux中用于进程替换，允许一个进程加载并执行新的程序，同时保留当前进程的标识符和资源。它们的不同之处在于如何处理程序路径和环境变量，以及参数的传递方式。在实际编程中，根据具体...
Python中的进程分支fork和exec详解
09-22
主要介绍了Python中的进程分支fork和exec详解,本文用实例讲解fork()的使用,并讲解了exec相关的8个方法等内容,需要的朋友可以参考下
OS.rar_fork孙子进程_创建孙子进程
09-23
在《OS.rar_fork孙子进程_创建孙子进程》这个主题中，我们将深入探讨`fork()`如何被用来创建子进程以及孙子进程，以及`exec()`函数族在这一过程中的作用。 `fork()`函数是一个非常特殊的函数，当它被调用时，操作...
python基础教程：Python中的进程分支fork和exec详解
12-21
`exec`系列函数可以用来在当前进程中替换执行另一个程序，而不是创建新的进程。`exec`调用后，原进程的内存空间会被新程序的内容所取代，因此`exec`函数不会返回，除非出现错误。 `os.execv()`、`os.execl()`、`os....
进程程序替换
！
10-19 471
用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程可以用过要调用一种exec函数去执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id没有改变。
进程程序替换及shell的实现
zhuboke3344的博客
03-24 571
一、进程程序替换用fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往强调一种exec函数执行另一个程序。当进程调用exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动历程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。替换函数#include&lt;stdio.h&gt; int execl(const ...
fork-父子进程读写文件的偏移量（linux4.0.4）
geshifei的博客
02-10 1250
一、背景 本文阐述的问题是：fork进程后父子进程操作文件的偏移量是否相同？ 该问题可以用以下代码来展示，如您能知道代码执行后forkfile文件的内容是什么，那么请略过此文。 #include &lt;stdio.h&gt; #include &lt;unistd.h&gt; #include &lt;sys/types.h&gt; #include &lt...
计算机系统大作业
littlebear_的博客
05-20 153
计算机系统大作业
父子进程间文件共享
静沐暖阳的博客
11-01 2232
fork函数调用一次，返回两次。在新创建的过程中返回一次，返回值为0.在原来的进程中返回一次，返回值是新进程的pid。 通过fork函数创建的进程为新进程的父进程。即就是，通过fork创建的进程与原进程是父子关系。孤儿进程：当父进程结束以后，子进程未结束，子进程的父进程变为init。init这个进程是守护进程，它负责处理这些孤儿进程退出以后的一些状态。 僵死进程：(1)父进程未结束，子进程结束，
【进程复制】
m0_56246173的博客
11-15 405
输出六个程序刚开始进入进程复制时 ,i都等于0，我们首先执行父进程，父进程先输出一个A，再次进入循环，父进程又一次进行分裂，分裂之后的父子进程i=1，所以此处的父子进程都会输出一个A，第一次分裂之后的父进程输出三个A，再看第一次分裂之后的子进程，同父进程一样，先输出一个A，再次进入循环，再次分裂，分裂的两个程序都输出A，所以第一次分裂的子进程输出三个A，随意总共输出6个A，如图。此处是三个A，考察返回值。此处输出两个A，程序刚开始先进行复制，父进程继续向下运行，输出一个A，子进程也继续输出一个A。
进程间通信之管道篇
最新发布
JJR_YZ的博客
05-16 837
进程间通信管道的笔记
进程间通信之管道通信
believe_s的博客
08-17 572
两个程序之间传递数据的一种简单方法是使用popen和pclose。#include <stdio.h> FILE *popen(const char *command, const char *type); int pclose(FILE *stream); popen函数允许一个程序将另一个程序作为新进程来启动，并可以传递数据给它或者通过它接收数据。
Linux学习-进程管理
skyline_zx的专栏
10-09 375
创建进程 Linux系统中，调用fork函数通过复制一个现有进程来创建一个新的进程，在调用结束时，再返回点这个相同的位置上，父进程恢复执行，子进程开始执行。Linux的fork使用写时拷贝（copy-on-write）页实现，资源的复制只有在写入时才进行，在此之前，只以只读方式共享，这种技术使地址空间上的页的拷贝被推迟到实际发生写入时才进行。fork的实际开销就是复制父进程的页表以及给子进程创建
深入理解Linux进程：从fork到exec
"这篇资源主要介绍了C语言中的进程相关知识，包括进程的概念、复制进程的`fork`函数、替换进程映像的`exec`函数以及守护进程。文章着重阐述了进程与程序的区别，并讲解了Linux操作系统中进程的结构和内存布局。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值