程序博客网 > dating付费软件靠谱吗

父子进程之间的关系

来源：互联网 发布：dating付费软件靠谱吗 编辑：程序博客网 时间：2024/04/25 15:10

摘要：本文详解介绍fork()函数的基本使用，以及父子进程之间的关系.子进程对变量的改变不会影响到父进程、子进程对父进程文件流缓冲区的处理和子进程对父进程打开的文件描述符的处理.

创建进程

1.fork()函数

函数定义：
    #include <unistd.h>
    pid_t fork(void);
返回值：如果返回值大于零，表明处于父进程上下文环境中，返回值是子进程的ID.如果返回值是零，表明处于子进程上下文环境中.其他返回值（小于零）表明调用fork()函数出错，仍处于父进程上下文环境中.
函数说明：
    由fork()函数创建的新进程被称为子进程.fork()函数被调用一次，但返回两次，两次的返回值不同，子进程的返回值是0，父进程的返回值是新进程的进程ID.
    一个进程的子进程可以有多个，并且没有一个函数使一个进程可以获得其所有子进程的进程ID.
    一个进程只会有一个父进程，所以任意一个子进程都可以通过调用getppid()函数获取其父进程的进程ID.
    fork()函数调用成功后，将为子进程申请PCB和用户内存空间.子进程是父进程的副本.在用户空间将复制父进程用户空间所有数据（代码段、数据段、BBS、堆、栈），复制父进程内核空间PCB中的绝大多数信息.子进程从父进程继承下例属性：有效用户、组号、进程组号、环境变量、对文件的执行时关闭标志、信号处理方式设置、信号屏蔽集合、当前工作目录、根目录、文件模式掩码、文件大小限制和打开的文件描述符（特别注意：共用同一文件表项）.

    子进程在创建后和父进程同时执行，竞争系统资源，谁先谁后，取决于内核所使用调度算法.子进程的执行位置为fork返回位置.

2.创建子进程

例子1：演示fork函数的基本使用方法.
[cpp] view plain copy
print?
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. #include <sys/types.h>  
  4. int main()  
  5. {  
  6.         pid_t pid;  
  7.         if((pid=fork())==-1)  
  8.                 printf("fork error\n");  
  9.         printf("a example of fork,pid = %d\n",getpid());  
  10.         return 0;  
  11. }  

输出：

：a example of fork,pid = 2798
：a example of fork,pid = 2797
    从例子1可以看出，fork()函数后的代码在子进程中也被执行.实际上，其他代码也在子进程的代码段中，只是子进程执行的位置为fork返回位置，其之前的代码无法执行罢了.
例子2：返回值大于0（返回PID）的代码在父进程执行，返回值为0则在子进程执行.
[cpp] view plain copy
print?
  1. #include <stdio.h>  
  2. #include <sys/types.h>  
  3. #include <unistd.h>  
  4. int main()  
  5. {  
  6.         pid_t pid;  
  7.         if((pid=fork())==-1)  
  8.         {  
  9.                 printf("fork error\n");  
  10.         }  
  11.         else if(pid == 0 )  
  12.         {  
  13.                 printf("pid:%d in the child process \n",pid);  
  14.         }  
  15.         else  
  16.         {  
  17.                 printf("pid:%d in the parent process\n",pid);  
  18.         }  
  19.         return 0;  
  20. }  

输出：

：pid:2923 in the parent process
：pid:0 in the child process


3.子进程对变量的改变不会影响到父进程

例子3：子进程和父进程各有一份变量的副本
[cpp] view plain copy
print?
  1. #include <unistd.h>  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. int glob = 10;  
  5. int main()  
  6. {  
  7.         int var = 100;  
  8.         pid_t pid = getpid();  
  9.         printf("before fork:\n");  
  10.         printf("pid=%d, glob=%d, var=%d\n",pid,glob,var);  
  11.   
  12.         printf("after fork:\n");  
  13.         if((pid=fork())<0)  
  14.         {  
  15.                 printf("error fork:%m\n");  
  16.                 exit(-1);  
  17.         }  
  18.         else if(pid==0)  
  19.         {  
  20.                 glob++;  
  21.                 var++;  
  22.         }  
  23.         else  
  24.         {  
  25.                 sleep(2);  
  26.         }  
  27.   
  28.         printf("pid = %d, glob = %d, var = %d\n",getpid(),glob,var);  
  29.         return 0;  
  30. }  

输出：

：before fork:
：pid=2664, glob=10, var=100
：after fork:
：pid = 2665, glob = 11, var = 101
：pid = 2664, glob = 10, var = 100
    可以看出，对于变量glob和var，在子进程中进行了自加，但是在父进程中，变量的值没有改变；显然，父子进程各自拥有这一变量的副本，互不影响.


4.子进程对父进程文件流缓冲区的处理

    文件流缓冲区的资源位于用户空间，因此，在创建子进程时，子进程的用户空间将复制父进程的用户空间所有信息，显然，也包含流缓冲区的内容.如果留缓冲区中有临时的信息，则通同样复制到子进程的用户空间流缓冲中.
例子4：子进程对父进程文件流缓冲区的处理.
[cpp] view plain copy
print?
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. #include <stdlib.h>  
  4. int main()  
  5. {  
  6.         pid_t pid;  
  7.   
  8.         //有回车，先输出  
  9.         printf("before fork,have enter\n");  
  10.   
  11.         //没有回车，先输出到缓冲区  
  12.         printf("before fork,no enter:pid=%d\t",getpid());  
  13.         pid = fork();  
  14.         if(pid == 0)  
  15.         {  
  16.                 printf("\nchild,after fork：pid=%d\n",getpid());  
  17.         }  
  18.         else  
  19.         {  
  20.                 printf("\nparent,after fork: pid=%d\n",getpid());  
  21.         }  
  22.         return 0;  
  23. }  

输出：

：before fork,have enter
：before fork,no enter:pid=2977
：parent,after fork: pid=2977
：before fork,no enter:pid=2977
：child,after fork：pid=2978
    为什么“before fork,have enter”只输出一次？
    首先明确一点，如果标准输出连到终端设备，则它是行缓冲或者全缓冲.“before fork,have enter”只输出一次，是因为标准输出缓冲区由换行符冲洗，在下面创建子进程时，复制的缓冲区已经没有该数据了.
    为什么“before fork,no enter:pid=2977”输出两次？
    子进程和父进程都输出了“before fork,no enter:pid=2977”，但是，为什么子进程会输出呢？子进程开始执行的位置是在fork函数返回处，不会执行fork函数之前的代码，虽然该代码被复制到子进程中.之所以出现两次输出，是因为父进程中的“printf("before fork,no enter:pid=%d\t",getpid());”没有回车，就是这条语句输出的结果还在缓冲区，缓冲区没有冲洗，没有真正输出.在创建子进程时，这父进程的缓冲区也会被复制到子进程的进程空间中，所以子进程在输出时，刷新缓冲区时，也会将“printf("before fork,no enter:pid=%d\t",getpid());”的结果输出.
    如果程序是这样子运行 ./a.out >out.txt.查看out.txt文件，可得到以下结果.
before fork,have enter
before fork,no enter:pid=2716
parent,after fork: pid=2716
before fork,have enter   ====》多了这一行
before fork,no enter:pid=2716
child,after fork：pid=2717
    为什么？“before fork,have enter”输出了两次.
    标准输出重定向到文件时，在调用fork函数时，该数据还在缓冲区，没有输出，这里的换行符没有像上面那样起到刷新缓冲区的作用，只是简单的换行，所以当父进程将数据复制到子进程时，该缓冲区的数据也被复制到子进程了.


5.子进程对父进程打开的文件描述符的处理

    fork函数创建子进程后，子进程将复制父进程的数据段、BBS段.代码段.堆空间、栈空间和文件描述符，而对于文件描述符关联的内核文件表项，则是此采用共享的方式.
例子5: 子进程对父进程打开的文件描述符的处理
[cpp] view plain copy
print?
  1. #include <sys/types.h>  
  2. #include <unistd.h>  
  3. #include <stdio.h>  
  4. #include <stdlib.h>  
  5. #include <string.h>  
  6. #include <fcntl.h>  
  7.   
  8. int main()  
  9. {  
  10.         pid_t pid;  
  11.         int fd;  
  12.         int i=1;  
  13.         int status;  
  14.         char *ch1="advanced";  
  15.         char *ch2=" programming";  
  16.         char *ch3=" int the unix Environment";  
  17.   
  18.         fd = open("test.txt",O_RDWR|O_CREAT,0644);  
  19.         if(fd==-1)  
  20.         {  
  21.                 printf("open or creat file error:%m\n");  
  22.                 exit(-1);  
  23.         }  
  24.         write(fd,ch1,strlen(ch1));  
  25.         pid=fork();  
  26.         if(pid==-1)  
  27.         {  
  28.                 printf("error fork\n");  
  29.                 exit(-1);  
  30.         }  
  31.         else if(pid==0)  
  32.         {  
  33.                 i=2;  
  34.                 printf("in child process\n");  
  35.                 printf("i=%d\n",i);  
  36.                 if(write(fd,ch2,strlen(ch2))==-1)  
  37.                 {  
  38.                         printf("child write error:%m\n");  
  39.                         exit(-1);  
  40.                 }  
  41.         }  
  42.         else  
  43.         {  
  44.                 sleep(1);  
  45.                 printf("int parent process\n");  
  46.                 printf("i=%d\n",i);  
  47.                 if(write(fd,ch3,strlen(ch3))==-1)  
  48.                 {  
  49.                         printf("parent wirte error%m\n");  
  50.                         exit(-1);  
  51.                 }  
  52.                 wait(&status);  
  53.         }  
  54.   
  55.         return 0;  
  56. }  

输出：cat test.txt

：advanced programming int the unix Environment
    可以看出，父子进程共同对一个文件操作，且写入数据不交叉覆盖，说明父子进程共享同一个文件偏移量，共享文件表项.如图1子进程对打开文件的处理方式.
 
图1 子进程对打开文件的处理方式


阅读全文
1 0
dating付费软件靠谱吗 dating付费软件靠谱吗
原创粉丝点击
热门IT博客
linux清理目录linux清理目录
卡会网络卡会网络
怎么加入淘宝联盟
error 1130 mysql
网络推广客服做什么的
真实的美国 知乎
淘宝网货架
dj姆本加数据
手机提示网络错误
井伊直弼 知乎
网络的坏处英文作文
java中级开发工程师
作业调度算法
mac退出预览
淘宝美工视频教程全套
数控车g41g42编程实例
淘宝上小镇姗姗有两家
烯牛数据公司地址
长沙网络推广168986
淘宝物品拍照技巧
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 单证硕士有用吗 在职研究生单证和双证的区别 单证 在职研究生 在职硕士单证 单证硕士废了 单证员是做什么的 在职研究生单证是什么证 单证研究生不如不读 外贸单证考试 英语单词 英文单词 英语单词表 一起消单词 墨墨背单词 星期单词 读我背单词 扇贝单词 墨墨单词 能飞背单词 单词 知米背单词 颜色单词 月份单词 水果单词 有声单词 背单词助手 背单词软件 九年级单词 四级单词 初中单词 锁屏单词 极光单词 完美单词 a开头单词 白色单词 上英语单词 单词突击赢 背英语单词 学单词 单词大全 听英语单词

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里