精华内容
下载资源
问答
  • fork函数

    2020-12-27 00:00:30
    fork函数fork函数简介实验前的准备1.安装虚拟机VMware,配置系统环境2.学习Linux的命令使用3.拷入代码,运行产生实验结果分析fork函数fork1()fork6()总结 fork函数简介 fork()函数将运行着的程序分成2个(几乎)完全...

    fork函数简介

    fork()函数将运行着的程序分成2个(几乎)完全一样的进程,每个进程都启动一个从代码的同一位置开始执行的线程。这两个进程中的线程继续执行,就像是两个用户同时启动了该应用程序的两个副本。我把这两个进程分别称之为父进程和子进程。

    实验前的准备

    1.安装虚拟机VMware,配置系统环境

    具体安装过程只需稍微百度一下便可知晓,这里就不过多赘述。

    2.学习Linux的命令使用

    为了运行forks函数的代码,我们需要提前了解Linux的命令使用

    1.命令:cd 目录

    cd / 切换到根目录
    cd /usr 切换到根目录下的usr目录
    cd …/ 切换到上一级目录 或者 cd …
    cd ~ 切换到home目录
    cd - 切换到上次访问的目录

    2.命令:find 目录 参数 文件名称

    示例:find /usr/tmp -name ‘a*’ 查找/usr/tmp目录下的所有以a开头的目录或文件

    3.命令:kill pid 或者 kill -9 pid(强制杀死进程) pid:进程号

    3.拷入代码,运行产生实验结果

    注:我的电脑不能直接将原电脑的文件直接拖入虚拟机,所以是通过QQ邮箱来发送和接受代码文件,产生这种情况的原因尚未知晓。

    分析fork函数

    fork2()


    实验结果:
    在这里插入图片描述
    分析:在这里插入图片描述
    如图所示的进程图即可说明,每当其运行到fork()函数时,就会分出子进程和父进程,L0在第一个fork()之前,所以只打印一次,而L1在两个fork()之间,则打印两次,而bye在两个fork()后面,所以打印四次。
    注:因为子进程和父进程运行随机,不同时间运行时,打印出的结果会不同,打印次序会变化。

    fork1()

    在这里插入图片描述
    显示结果:
    在这里插入图片描述
    分析:子进程时pid==0,打印"child …"部分,++x得x == 2,父进程时,pid == 1,打印"parent …"部分,–x得x == 0,而无论是父进程还是子进程,执行玩if语句后都会执行后续的printf(bye …),所以最终的显示结果为四行语句,且显示顺序可以不同。

    fork9()

    在这里插入图片描述
    显示结果为:
    在这里插入图片描述
    分析:fork()函数的父进程和子进程的执行顺序随机,图中所示情况为先执行父进程,打印了HP,而后出现了wait()语句,意思为等待子进程结束,所以此时子进程随比父进程满,它的打印仍然是HC先于父进程的CT,最后进程结束后打印bye,下图为流程示意图。
    在这里插入图片描述

    fork7()

    在这里插入图片描述
    显示结果:
    在这里插入图片描述
    分析:从结果上看不出有什么问题,但程序并未终止,父进程有一个无限循环,子进程结束后,如果父进程一直不结束,会变为僵死进程,这时需要杀死它的父进程才能杀死僵死进程。

    fork8()

    在这里插入图片描述
    显示结果:
    在这里插入图片描述
    分析:和fork7()一样,虽然结果显示看起来并无问题,但其实程序运行后没有结束,观察程序可知,子进程中有一个无限循环,这时可用kill直接杀死。

    fork14()

    在这里插入图片描述
    实验结果:
    在这里插入图片描述
    而后进程会卡死。
    分析:孩子进程正常退出时,会向父进程发送 SIGCHLD 信号,signal 函数接收到该信号,调用 handler 函数处理handler 函数等待一个子进程结束,然后 ccount 会减一父进程由于 ccount = N,一开始会陷入死循环,直到子进程全部被回收为止但是如果已有一个子进程先 sleep 结束向父进程发送信号,到父进程处理该信号之前,所有的子进程发送的 SIGCHLD 信号都会被弃,因此这个函数的输出是不确定的,并且如果子进程未全部结束,父进程会一直持续下去,此时挂起当前进程后使用 ps 命令查看则会看到已经结束的子进程会变成僵死进程。

    总结

    上述的几个fork()函数涉及到几个不同的语句,fork2()是最基本的fork()函数进程,fork1()涉及if()语句,fork7()和fork8()涉及无限循环语句,fork9()涉及wait()函数,而fork16()则与信号有关。通过对上述fork()函数的运行和分析,自己对fork()函数有了一个清晰的认识,懂得了wait()以及信号的理解方式,对今后的学习铺好了基础。

    展开全文
  • fork函数的写时拷贝

    2020-08-10 15:57:43
    fork函数用于创建子进程,典型的调用一次,返回两次的函数,其中返回子进程的PID和0,其中调用进程返回了子进程的PID,而子进程则返回了0,这是一个比较有意思的函数,但是两个进程的执行顺序是不定的。
  • fork函数使用

    2017-10-23 17:57:35
    关于fork函数的介绍,和测试程序,原版fork linux平台
  • fork函数详解

    万次阅读 多人点赞 2018-07-01 21:45:37
    fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程,也就是两个进程可以做完全相同的事,但如果初始参数或者传入的变量不同,两个进程也可以做不同的事。 一个进程调用fork()函数后,系统先给新的...

    一、fork入门知识

         一个进程,包括代码、数据和分配给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程,也就是两个进程可以做完全相同的事,但如果初始参数或者传入的变量不同,两个进程也可以做不同的事。
        一个进程调用fork()函数后,系统先给新的进程分配资源,例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中,只有少数值与原来的进程的值不同。相当于克隆了一个自己。

         我们来看一个例子:

    [cpp]  view plain  copy
    1. /* 
    2.  *  fork_test.c 
    3.  *  version 1 
    4.  *  Created on: 2010-5-29 
    5.  *      Author: wangth 
    6.  */  
    7. #include <unistd.h>  
    8. #include <stdio.h>   
    9. int main ()   
    10. {   
    11.     pid_t fpid; //fpid表示fork函数返回的值  
    12.     int count=0;  
    13.     fpid=fork();   
    14.     if (fpid < 0)   
    15.         printf("error in fork!");   
    16.     else if (fpid == 0) {  
    17.         printf("i am the child process, my process id is %d/n",getpid());   
    18.         printf("我是爹的儿子/n");//对某些人来说中文看着更直白。  
    19.         count++;  
    20.     }  
    21.     else {  
    22.         printf("i am the parent process, my process id is %d/n",getpid());   
    23.         printf("我是孩子他爹/n");  
    24.         count++;  
    25.     }  
    26.     printf("统计结果是: %d/n",count);  
    27.     return 0;  
    28. }  

         运行结果是:
        i am the child process, my process id is 5574
        我是爹的儿子
        统计结果是: 1
        i am the parent process, my process id is 5573
        我是孩子他爹
        统计结果是: 1

        在语句fpid=fork()之前,只有一个进程在执行这段代码,但在这条语句之后,就变成两个进程在执行了,这两个进程的几乎完全相同,将要执行的下一条语句都是if(fpid<0)……
        为什么两个进程的fpid不同呢,这与fork函数的特性有关。fork调用的一个奇妙之处就是它仅仅被调用一次,却能够返回两次,它可能有三种不同的返回值:
        1)在父进程中,fork返回新创建子进程的进程ID;
        2)在子进程中,fork返回0;
        3)如果出现错误,fork返回一个负值;

        在fork函数执行完毕后,如果创建新进程成功,则出现两个进程,一个是子进程,一个是父进程。在子进程中,fork函数返回0,在父进程中,fork返回新创建子进程的进程ID。我们可以通过fork返回的值来判断当前进程是子进程还是父进程。

        引用一位网友的话来解释fpid的值为什么在父子进程中不同。“其实就相当于链表,进程形成了链表,父进程的fpid(p 意味point)指向子进程的进程id, 因为子进程没有子进程,所以其fpid为0.
        fork出错可能有两种原因:
        1)当前的进程数已经达到了系统规定的上限,这时errno的值被设置为EAGAIN。
        2)系统内存不足,这时errno的值被设置为ENOMEM。
        创建新进程成功后,系统中出现两个基本完全相同的进程,这两个进程执行没有固定的先后顺序,哪个进程先执行要看系统的进程调度策略。
        每个进程都有一个独特(互不相同)的进程标识符(process ID),可以通过getpid()函数获得,还有一个记录父进程pid的变量,可以通过getppid()函数获得变量的值。
       
     fork执行完毕后,出现两个进程,

        有人说两个进程的内容完全一样啊,怎么打印的结果不一样啊,那是因为判断条件的原因,上面列举的只是进程的代码和指令,还有变量啊。
        执行完fork后,进程1的变量为count=0,fpid!=0(父进程)。进程2的变量为count=0,fpid=0(子进程),这两个进程的变量都是独立的,存在不同的地址中,不是共用的,这点要注意。可以说,我们就是通过fpid来识别和操作父子进程的。
        还有人可能疑惑为什么不是从#include处开始复制代码的,这是因为fork是把进程当前的情况拷贝一份,执行fork时,进程已经执行完了int count=0;fork只拷贝下一个要执行的代码到新的进程。

    二、fork进阶知识

        先看一份代码:

    [cpp]  view plain  copy
    1. /* 
    2.  *  fork_test.c 
    3.  *  version 2 
    4.  *  Created on: 2010-5-29 
    5.  *      Author: wangth 
    6.  */  
    7. #include <unistd.h>  
    8. #include <stdio.h>  
    9. int main(void)  
    10. {  
    11.    int i=0;  
    12.    printf("i son/pa ppid pid  fpid/n");  
    13.    //ppid指当前进程的父进程pid  
    14.    //pid指当前进程的pid,  
    15.    //fpid指fork返回给当前进程的值  
    16.    for(i=0;i<2;i++){  
    17.        pid_t fpid=fork();  
    18.        if(fpid==0)  
    19.            printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
    20.        else  
    21.            printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
    22.    }  
    23.    return 0;  
    24. }  

        运行结果是:
        i son/pa ppid pid  fpid
        0 parent 2043 3224 3225
        0 child  3224 3225    0
        1 parent 2043 3224 3226
        1 parent 3224 3225 3227
        1 child     1 3227    0
        1 child     1 3226    0
     
        这份代码比较有意思,我们来认真分析一下:
        第一步:在父进程中,指令执行到for循环中,i=0,接着执行fork,fork执行完后,系统中出现两个进程,分别是p3224和p3225(后面我都用pxxxx表示进程id为xxxx的进程)。可以看到父进程p3224的父进程是p2043,子进程p3225的父进程正好是p3224。我们用一个链表来表示这个关系:
        p2043->p3224->p3225 
        第一次fork后,p3224(父进程)的变量为i=0,fpid=3225(fork函数在父进程中返向子进程id),代码内容为:

    [c-sharp]  view plain  copy
    1. for(i=0;i<2;i++){  
    2.     pid_t fpid=fork();//执行完毕,i=0,fpid=3225  
    3.     if(fpid==0)  
    4.        printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
    5.     else  
    6.        printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
    7. }  
    8. return 0;  

        p3225(子进程)的变量为i=0,fpid=0(fork函数在子进程中返回0),代码内容为:

    [c-sharp]  view plain  copy
    1. for(i=0;i<2;i++){  
    2.     pid_t fpid=fork();//执行完毕,i=0,fpid=0  
    3.     if(fpid==0)  
    4.        printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
    5.     else  
    6.        printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
    7. }  
    8. return 0;  

        所以打印出结果:
        0 parent 2043 3224 3225
        0 child  3224 3225    0

        第二步:假设父进程p3224先执行,当进入下一个循环时,i=1,接着执行fork,系统中又新增一个进程p3226,对于此时的父进程,p2043->p3224(当前进程)->p3226(被创建的子进程)。
        对于子进程p3225,执行完第一次循环后,i=1,接着执行fork,系统中新增一个进程p3227,对于此进程,p3224->p3225(当前进程)->p3227(被创建的子进程)。从输出可以看到p3225原来是p3224的子进程,现在变成p3227的父进程。父子是相对的,这个大家应该容易理解。只要当前进程执行了fork,该进程就变成了父进程了,就打印出了parent。
        所以打印出结果是:
        1 parent 2043 3224 3226
        1 parent 3224 3225 3227
     
        第三步:第二步创建了两个进程p3226,p3227,这两个进程执行完printf函数后就结束了,因为这两个进程无法进入第三次循环,无法fork,该执行return 0;了,其他进程也是如此。
        以下是p3226,p3227打印出的结果:
        1 child     1 3227    0
        1 child     1 3226    0
     
        细心的读者可能注意到p3226,p3227的父进程难道不该是p3224和p3225吗,怎么会是1呢?这里得讲到进程的创建和死亡的过程,在p3224和p3225执行完第二个循环后,main函数就该退出了,也即进程该死亡了,因为它已经做完所有事情了。p3224和p3225死亡后,p3226,p3227就没有父进程了,这在操作系统是不被允许的,所以p3226,p3227的父进程就被置为p1了,p1是永远不会死亡的,至于为什么,这里先不介绍,留到“三、fork高阶知识”讲。
        总结一下,这个程序执行的流程如下:

         这个程序最终产生了3个子进程,执行过6次printf()函数。
        我们再来看一份代码:

    [cpp]  view plain  copy
    1. /* 
    2.  *  fork_test.c 
    3.  *  version 3 
    4.  *  Created on: 2010-5-29 
    5.  *      Author: wangth 
    6.  */  
    7. #include <unistd.h>  
    8. #include <stdio.h>  
    9. int main(void)  
    10. {  
    11.    int i=0;  
    12.    for(i=0;i<3;i++){  
    13.        pid_t fpid=fork();  
    14.        if(fpid==0)  
    15.            printf("son/n");  
    16.        else  
    17.            printf("father/n");  
    18.    }  
    19.    return 0;  
    20.   
    21. }  

         它的执行结果是:
        father
        son
        father
        father
        father
        father
        son
        son
        father
        son
        son
        son
        father
        son 
        这里就不做详细解释了,只做一个大概的分析。
        for        i=0         1           2
                  father     father     father
                                            son
                                son       father
                                            son
                   son       father     father
                                            son
                                son       father
                                            son
        其中每一行分别代表一个进程的运行打印结果。
        总结一下规律,对于这种N次循环的情况,执行printf函数的次数为2*(1+2+4+……+2N-1)次,创建的子进程数为1+2+4+……+2N-1个。(感谢gao_jiawei网友指出的错误,原本我的结论是“执行printf函数的次数为2*(1+2+4+……+2N)次,创建的子进程数为1+2+4+……+2”,这是错的)
        网上有人说N次循环产生2*(1+2+4+……+2N)个进程,这个说法是不对的,希望大家需要注意。

        数学推理见http://202.117.3.13/wordpress/?p=81(该博文的最后)。
        同时,大家如果想测一下一个程序中到底创建了几个子进程,最好的方法就是调用printf函数打印该进程的pid,也即调用printf("%d/n",getpid());或者通过printf("+/n");来判断产生了几个进程。有人想通过调用printf("+");来统计创建了几个进程,这是不妥当的。具体原因我来分析。
        老规矩,大家看一下下面的代码:

    [cpp]  view plain  copy
    1. /* 
    2.  *  fork_test.c 
    3.  *  version 4 
    4.  *  Created on: 2010-5-29 
    5.  *      Author: wangth 
    6.  */  
    7. #include <unistd.h>  
    8. #include <stdio.h>  
    9. int main() {  
    10.     pid_t fpid;//fpid表示fork函数返回的值  
    11.     //printf("fork!");  
    12.     printf("fork!/n");  
    13.     fpid = fork();  
    14.     if (fpid < 0)  
    15.         printf("error in fork!");  
    16.     else if (fpid == 0)  
    17.         printf("I am the child process, my process id is %d/n", getpid());  
    18.     else  
    19.         printf("I am the parent process, my process id is %d/n", getpid());  
    20.     return 0;  
    21. }  

        执行结果如下:
        fork!
        I am the parent process, my process id is 3361
        I am the child process, my process id is 3362 
        如果把语句printf("fork!/n");注释掉,执行printf("fork!");
        则新的程序的执行结果是:
        fork!I am the parent process, my process id is 3298
        fork!I am the child process, my process id is 3299 
        程序的唯一的区别就在于一个/n回车符号,为什么结果会相差这么大呢?
        这就跟printf的缓冲机制有关了,printf某些内容时,操作系统仅仅是把该内容放到了stdout的缓冲队列里了,并没有实际的写到屏幕上。但是,只要看到有/n 则会立即刷新stdout,因此就马上能够打印了。
        运行了printf("fork!")后,“fork!”仅仅被放到了缓冲里,程序运行到fork时缓冲里面的“fork!”  被子进程复制过去了。因此在子进程度stdout缓冲里面就也有了fork! 。所以,你最终看到的会是fork!  被printf了2次!!!!
        而运行printf("fork! /n")后,“fork!”被立即打印到了屏幕上,之后fork到的子进程里的stdout缓冲里不会有fork! 内容。因此你看到的结果会是fork! 被printf了1次!!!!
        所以说printf("+");不能正确地反应进程的数量。
        大家看了这么多可能有点疲倦吧,不过我还得贴最后一份代码来进一步分析fork函数。

    [cpp]  view plain  copy
    1. #include <stdio.h>  
    2. #include <unistd.h>  
    3. int main(int argc, char* argv[])  
    4. {  
    5.    fork();  
    6.    fork() && fork() || fork();  
    7.    fork();  
    8.    return 0;  
    9. }  

        问题是不算main这个进程自身,程序到底创建了多少个进程。
        为了解答这个问题,我们先做一下弊,先用程序验证一下,到此有多少个进程。

    [c-sharp]  view plain  copy
    1. #include <stdio.h>  
    2. int main(int argc, char* argv[])  
    3. {  
    4.    fork();  
    5.    fork() && fork() || fork();  
    6.    fork();  
    7.    printf("+/n");  
    8. }  

        答案是总共20个进程,除去main进程,还有19个进程。
        我们再来仔细分析一下,为什么是还有19个进程。
        第一个fork和最后一个fork肯定是会执行的。
        主要在中间3个fork上,可以画一个图进行描述。
        这里就需要注意&&和||运算符。
        A&&B,如果A=0,就没有必要继续执行&&B了;A非0,就需要继续执行&&B。
        A||B,如果A非0,就没有必要继续执行||B了,A=0,就需要继续执行||B。
        fork()对于父进程和子进程的返回值是不同的,按照上面的A&&B和A||B的分支进行画图,可以得出5个分支。

        

         加上前面的fork和最后的fork,总共4*5=20个进程,除去main主进程,就是19个进程了。

    三、fork高阶知识

            这一块我主要就fork函数讲一下操作系统进程的创建、死亡和调度等。因为时间和精力限制,我先写到这里,下次找个时间我争取把剩下的内容补齐。

    展开全文
  • fork函数和子函数进程

    2012-07-19 06:39:49
    易懂易用,对于初学者来说是个十分实用的对初学知识的巩固与了解。
  • fork函数调用全过程

    2020-02-25 13:45:52
    1. sys_fork函数

    1.概述

    在应用层调用fork()函数,内核调用函数关系,以及作用?
    函数调用关系如下图:

    sys_fork()-->do_fork()--->copy_process()--->wake_up_new_task()
    

    2. sys_fork函数

    sys_fork函数调用do_fork并传入SIGCHLD参数。

    631 asmlinkage int sys_fork(struct pt_regs regs)                                    
    632 {                                                                               
    633         return do_fork(SIGCHLD, regs.esp, &regs, 0, NULL, NULL);                
    634 } 
    

    3. do_fork函数

    1124 long do_fork(unsigned long clone_flags,                                         
    1125               unsigned long stack_start,                                        
    1126               struct pt_regs *regs,                                             
    1127               unsigned long stack_size,                                         
    1128               int __user *parent_tidptr,                                        
    1129               int __user *child_tidptr)                                         
    1130 {                                                                               
    1131         struct task_struct *p;                                                  
    1132         int trace = 0;                                                          
    1133         long pid = alloc_pidmap();                                              
    1134                                                                                 
    1135         if (pid < 0)                                                            
    1136                 return -EAGAIN;                                                 
    1137         if (unlikely(current->ptrace)) {                                        
    1138                 trace = fork_traceflag (clone_flags);                           
    1139                 if (trace)                                                      
    1140                         clone_flags |= CLONE_PTRACE;                            
    1141         }
    1142                                                                                 
    1143         p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);
    1144         /*                                                                      
    1145          * Do this prior waking up the new thread - the thread pointer          
    1146          * might get invalid after that point, if the thread exits quickly.                                                                                                                                  
    1147          */                                                                     
    1148         if (!IS_ERR(p)) {                                                       
    1149                 struct completion vfork;                                        
    1150                                                                                 
    1151                 if (clone_flags & CLONE_VFORK) {                                
    1152                         p->vfork_done = &vfork;                                 
    1153                         init_completion(&vfork);                                
    1154                 }                                                               
    1155                                                                                 
    1156                 if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
    1157                         /*                                                      
    1158                          * We'll start up with an immediate SIGSTOP.            
    1159                          */                                                     
    1160                         sigaddset(&p->pending.signal, SIGSTOP);                 
    1161                         set_tsk_thread_flag(p, TIF_SIGPENDING);                 
    1162                 }                                                               
    1163                                                                                 
    1164                 if (!(clone_flags & CLONE_STOPPED))                             
    1165                         wake_up_new_task(p, clone_flags);                       
    1166                 else                                                            
    1167                         p->state = TASK_STOPPED;                                
    1168                                                                                 
    1169                 if (unlikely (trace)) {                                         
    1170                         current->ptrace_message = pid;                          
    1171                         ptrace_notify ((trace << 8) | SIGTRAP);                 
    1172                 }                                                               
    1173                                                                                 
    1174                 if (clone_flags & CLONE_VFORK) {                                
    1175                         wait_for_completion(&vfork);                            
    1176                         if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))   
    1177                                 ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
    1178                 }                                                               
    1179         } else {                                                                
    1180                 free_pidmap(pid);                                               
    1181                 pid = PTR_ERR(p);                                               
    1182         }   
    1183         return pid;                                                             
    1184 }
    

    执行fork()函数后,do_fork()主要执行下面步骤:
    1)在1133行,通过alloc_pidmap()获得一个进程号。
    2)再1143行,copy_process()给新进程分配struct task和thread info的变量。
    2)在1165行,通过wake_up_new_task唤醒这个进程。
    3)在1183行,返回进程pid号。

    4. copy_process

    1111
    

    task_rq_lock

    功能: 通过struct task结构变量p,找到对应得cpu,然后得到这个cpu上的percpu变量runqueues(进程运行队列)。

     305 static runqueue_t *task_rq_lock(task_t *p, unsigned long *flags)                
     306         __acquires(rq->lock)                                                    
     307 {                                                                               
     308         struct runqueue *rq;                                                    
     309                                                                                 
     310 repeat_lock_task:                                                               
     311         local_irq_save(*flags);                                                 
     312         rq = task_rq(p);                                                        
     313         spin_lock(&rq->lock);                                                   
     314         if (unlikely(rq != task_rq(p))) {                                       
     315                 spin_unlock_irqrestore(&rq->lock, *flags);                      
     316                 goto repeat_lock_task;                                          
     317         }                                                                       
     318         return rq;                                                                                                                                                          
     319 } 
    

    宏task_rq的定义如下:

    task_rq(p)
     286 #define cpu_rq(cpu)             (&per_cpu(runqueues, (cpu)))                    
     287 #define this_rq()               (&__get_cpu_var(runqueues))                     
     288 #define task_rq(p)              cpu_rq(task_cpu(p))
    1146 static inline unsigned int task_cpu(const struct task_struct *p)                                                                                                                                             
    1147 {                                                                               
    1148         return p->thread_info->cpu;                                             
    1149 }
    

    展开就是:

    1)  task_rq(p)=====>cpu_rq(task_cpu(p))
    2)  cpu_rq(task_cpu(p))==========>cpu_rq(p->thread_info->cpu)
    3)  cpu_rq(p->thread_info->cpu)=====>&per_cpu(runqueues,p->thread_info->cpu)
    per_cpu(arg1,arg2)=====>就是访问arg2编号的cpu上的arg1变量。
    task_rq(p)==>就是访问p对应的cpu上的runqueues(类型为percpu)
    
    展开全文
  • 进程之fork函数的用法

    2020-11-24 17:27:54
    文章目录前言一、父子进程号的差别二、fork函数的返回值总结 前言 在liunx进程中,fork()函数是非常重要的,它是进程的缔造者,今天我们就来探索下关于fork()函数的一些用法 一、父子进程号的差别 fork()函数...


    前言

    在liunx进程中,fork()函数是非常重要的,它是进程的缔造者,今天我们就来探索下关于fork()函数的一些用法

    一、父子进程号的差别

    fork()函数创建进程后的情况是比较复杂的,一般来说,它会产生父子进程,而我们只需要对这两个进程来进行研究就可以解决大部分问题了。
    下面我们来看一个例子:

    #include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    
    int main()
    {
    
            pid_t pid;
                         //定一两个进程变量,用来存放进程号
            pid_t pid1;
    
            pid = getpid();//获取进程号的函数,使用很简单,返回值就是进程号
    
            printf("before fork: pid = %d\n",pid);//输出使用fork函数前的进程号,同接下来的做对比
    
            fork();//创建一个进程
    
            pid1 = getpid();
    
            printf("before fork: pid = %d\n",pid1);//输出使用fork函数后的进程号,同前面做对比
    
            if(pid == getpid()){//一般父进程的进程号等于原先的进程号,而子进程号则会发生改变
                    printf("this is father print\n");
            }else{
                    printf("this is child print,child pid = %d\n",getpid());
            }
            return 0;
    }
    

    再看看这个程序的运行结果:
    在这里插入图片描述
    可以很明显的看到出现了两个进程号,并且能够验证父子进程的进程号是不一致的,因而fork函数建立进程后,父进程和子进程会分别走向自己的那条路,它们之间互不干扰,当然它们运行的先后顺序目前我们仍然无法判断。

    二、fork函数的返回值

    前面我们知道了父子进程各自的进程号是不一样的,现在我们来探究一下fork函数的返回值到底是怎么样的,下面根据上面的demo来改变一下,继续测试:

    #include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    
    int main()
    {
    
            pid_t pid;
    
            pid_t pid1;
    
            pid_t retpid;
    
            pid = getpid();
    
            printf("before fork: pid = %d\n",pid);
    
            retpid = fork();//获取fork函数的返回值
    
            pid1 = getpid();
    
            printf("before fork: pid = %d\n",pid1);
    
            if(pid == getpid()){
                    printf("this is father print,the retpid = %d\n",retpid);//输出fork函数的返回值,看看它究竟返回的是什么
            }else{
                    printf("this is child print,retpid =%d  child pid = %d\n",retpid,getpid());
                                                                                                
            }
            return 0;
    }
    

    看看实际运行效果:
    在这里插入图片描述
    可以看到在父进程中fork函数的返回值是正的,而在子进程中则是为0,因而fork函数会发生两次返回,一次是大于零的,这是给父进程返回的,一次是等于零,这是给子进程返回的,当fork函数返回的值为-1时,则进程创建失败。

    总结

    fork的应用场景很多,因为当我们需要用到进程时,就必须用到这个函数,今天我们算是初步了解了它的用法以及一些概念,后续还会有更加深入的知识等着我们。

    展开全文
  • 1.fork函数基本作用 一个进程,包括代码、数据和分配给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程, 也就是两个进程可以做完全相同的事,但如果初始参数或者传入的变量不同,两个...
  • 为了实现Linux下多进程服务端,我们有必要掌握三个基础知识:fork函数、僵尸进程以及信号处理 fork函数 说明:多进程编程,说白了就是多个进程并发处理事件,通常我们运行一个程序的时候只有一个进程在执行任务,...
  • fork函数结果分析

    2019-11-06 22:55:39
    fork()函数结果分析 计算机系统基础-fork() fork()函数 运行结果 结果分析 进程图
  • 18-用fork函数创建新进程

    千次阅读 多人点赞 2018-09-05 14:29:02
    注意fork的返回值,由于fork调用成功后子进程也复制了一个fork函数,父子进程中各自有一个fork函数,父进程的fork返回值大于0(子进程pid),子进程的fork则返回0,如果fork调用失败,当前进程返回-1。 fork...
  • fork函数知识点

    2020-12-15 12:02:46
    进程控制何为进程进程的IDfork函数如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图...
  • 一、fork函数与vfork函数的简介(1)fork函数在Linux下fork函数很重要,它的作用是创建子进程,即在当前进程中创建一个新的进程,新进程为子进程,原来的进程为父进程。我们来看一下这个函数的返回值和类型#include ...
  • fork一个进程,fork()函数fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程,这个新产生的进程称为子进程。一个进程调用fork()函数后,系统先给新的进程...
  • linux内核 do_fork 函数源代码浅析。 经典讲解!
  • 2.fork 函数被调用一次,但返回两次, 两次返回的唯一区别是子进程的返回值是 0, 而父进程的返回值是新子进程的 PID。 3.子进程和父进程继续执行 fork 调用之后的指令。 在上图的存储空间布局中,父子进程只共享正文...
  • 操作系统---fork函数解析与例题详解

    千次阅读 2018-05-20 21:58:43
    一个现有进程可以调用fork函数创建一个新进程。由fork创建的新进程被称为子进程(child process)。fork函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回0值,而父进程中返回子进程ID。...
  • 理解fork函数

    2017-05-16 21:32:40
    fork函数原型: pid_t fork(void) fork函数较难理解的是:一次调用,两次返回。 其实,fork()不止调用一次,它是在父进程调用一次,在子进程也调用一次,通过两次调用的不同返回值来判断是位于父进程,还是位于子...
  • 原来刚刚开始做Linux下面的多进程编程的时候,对于下面这段代码感到很奇怪:  #include  #include  #include  #include  #include  #include  #define LEN 2  void err_exit(char*fmt,…);...
  • fork函数返回值问题

    千次阅读 2019-10-22 16:05:29
    一个现有进程可以调用fork函数创建一个新进程。由fork创建的新进程被称为子进程(child process)。fork函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。 具体细节如下图...
  • 父进程通过调用fork函数来创建一个新的运行的子进程。 父进程和子进程之间最大的区别就是PID不同 1)在父进程中,fork返回新创建子进程的PID; 2)在子进程中,fork返回0; 3)如果出现错误,fork返回一个负值 ...
  • C++ fork函数理解

    万次阅读 2018-05-29 11:26:51
    C++的fork函数用来“复制”一份主程序,即创建主进程的子进程。调用fork的同时,我的理解是,已经在内存中创建了“副本”进程,同时返回pid,所以在返回值之前,已经是主进程和子进程同时在运行了(如果fork成功的话...
  • fork函数及创建后台进程详解 文章目录fork函数及创建后台进程详解fork函数一、fork之后父子进程之间文件共享二、通过fork来创建后台运行的程序(守护进程)1.代码示例setsid()作用总结 fork函数 一个进程可以...
  • fork 函数详解

    2012-12-15 01:19:46
    fork 函数详解
  • 本文档内容是我自己写的一个关于fork函数新建进程并对调用流程进行分析的文档。 运行环境是win7安装vmware虚拟机里的linux系统,直接gcc编译得到的执行结果。 看完次文档后即可对fork有一个比较系统的认识。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 132,640
精华内容 53,056
关键字:

fork函数