精华内容
下载资源
问答
  • 父进程创建多个子进程的问题

    千次阅读 2014-10-29 20:27:58
    父进程创建子进程,看起来容易,返回值x

            父进程创建子进程,看起来容易,返回值等于零在子中,大于零0在父进程中。可是当遇到一个父进程需要创建多个子进程的时候,问题就变得复杂了,稍不留神你将创建出比你多好多的子进程,因为当在子进程中调用fork(),那么自己进程也会创建子进程,结果因此和在父进程中创建子进程有很大的不同。

           所以在fork时,一定要判定此时是不是在父进程中。

       

    int main()
    {
        pid_t pid[2];
        int i;
        printf("This is %d\n",getpid());
        for(i = 0;i < 3;i++ ){
            if((pid[0] = fork()) < 0){
                printf("Fork() Error!");
                exit(-1);
            }
            if(pid[0] == 0)
                printf("This is parent %d,child is %d\n",getppid(),getpid());
            
               
        }
        return 0;
    }

    此时创建了几个进程类?如果你的答案是3,那你就错了。答案是7个进程。
    解决方法
    void createsubprocess(int num)  
    {  
        pid_t pid;  
        int i;  
        for(i=0;i<num;i++)  
        {  
            pid=fork();  
            if(pid==0||pid==-1)  //子进程或创建进程失败均退出,这里是关键所在
            {  
                break;  
            }  
        }  
        if(pid==-1)  
        {  
            perror("fail to fork!\n");  
            exit(1);  
        }  
        else if(pid==0)  
        {  
            printf("子进程id=%d,其对应的父进程id=%d\n",getpid(),getppid());  
            exit(0);  
        }  
        else 
        {  
            printf("父进程id=%d\n",getpid());  
            exit(0);  
        }  
    }


    具体参考:http://www.360doc.com/content/12/0409/17/532901_202238408.shtml

    展开全文
  • 一、父进程创建子进程,使用fork(), 一次fork() 次返回,一次返回的是父进程自己,一次返回的是子进程的运行空间。 二、父进程必须监控子进程的运行状态,等待子进程退出后,使用wait()进行关闭,否则,如果父...

    一、父进程创建子进程,使用fork(), 一次fork() 两次返回,一次返回的是父进程自己,一次返回的是子进程的运行空间。

    二、父进程必须监控子进程的运行状态,等待子进程退出后,使用wait()进行关闭,否则,如果父进程先退出,子进程就没有父亲了,就变成了僵尸进程,此时退出时,就会被系统进程init监控到,然后由系统进程init进行关闭和释放资源。


    三、运行下列的代码,结果如下:


    [zhou@localhost code]$ ./a.out 
    I am child. my pid=3448 parent pid=3447 
    I am parent. my pid=3447  
     wait for child to exit ... 
    child pid = 3448 exit code=256 
     success for wait for child to exit. 
    [zhou@localhost code]$ 


    #include <unistd.h>
    #include <stdio.h>
    #include <errno.h>
    
    
    int main()
    {
            pid_t fpid;
            int count =0;
    
            fpid = fork();
            if( fpid < 0) 
            {
                    printf("\r\n error");
            }
            else if( 0 == fpid)
            {
                    printf("I am child. my pid=%ld parent pid=%ld \r\n", (long)getpid(),(long)getppid());
                    exit(1);
            }
            else
            {
                    int exitcode = 0;
                    long  ret;
    
                    sleep(1);
                    printf("I am parent. my pid=%d  \r\n", getpid());
    
                    printf(" wait for child to exit ... \r\n");
                    ret = wait(&exitcode);
                    while( -1 != ret )
                    {
                            printf("child pid = %ld exit code=%d \r\n", ret, exitcode);
                            if(errno == ECHILD) break;
    
                            sleep(1);
                            ret = wait(&exitcode);
                    }
    
                    printf(" success for wait for child to exit. \r\n");
            }
    
            return 0;
    }



    展开全文
  • 在Linux下我们可以用fork函数创建一...假设我们用如下代码在一个父进程创建两个子进程: void main() { pid_t pid1, pid2; pid1 = fork(); pid2 = fork(); if(pid1 == 0) { printf("This is the first child proces
    在Linux下我们可以用fork函数创建一个子进程,但是当我们需要在一个父进程下创建多个子进程时,有些需要注意的地方。假设我们用如下代码在一个父进程下创建两个子进程:
    void main()
    {
    pid_t pid1, pid2;
    pid1 = fork();
    pid2 = fork();
    if(pid1 == 0)
    {
    printf("This is the first child process!\n");
    exit(0);
    }

    if(pid2 == 0)
    {
    printf("This is the second child process!\n");
    sleep(2);
    exit(0);
    }

    if(pid1 != 0 &&  pid2 != 0)
    {
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);
    exit(0);
    }
    }
    如果我们用这个方式来创建两个子进程,则会出现一系列问题
    首先,你用ps aux命令,会发现一共有4个进程,其中3个子进程,多了一个
    其次,你会发现用这种方式无法检测到信号(signal)

    发生这些状况的主要原因是我们没有对进程ID进行判断。当我们在父进程创建一个子进程时,在内存中就会多出一个父进程的副本(完全一样的拷贝,包括代码段和数据段),但是两个进程都是从第一个fork后面开始执行的,所以如果后面直接出现第二个fork,则在父进程和子进程中都会再创建一个它们自己的子进程,这样就一共有4个进程了。
    同样,如果我们用kill,signal函数来传递接受信号,也会出问题。比如子进程1发送一个INT信号,子进程2在接收到这个信号后,打印"hello, kaito",若用如下方式来:
    if(pid1 == 0)
    {
    kill(pid2, SIGINT);
    exit(0);
    }

    if(pid2 == 0)
    {
    signal(SIGINT, func);
    pause();
    exit(0);
    }
    则发送不了信号,因为在第一个if里面pid1 == 0,说明在子进程1里面,子进程1它按道理没有子进程了,哪来的pid2,所以kill发送当然会失败。

    所以,我们在创建子进程之间一定要对当前进程进行判断,最好是只有在父进程里面,才创建子进程。则的如下代码
    #include "klib.h"

    void int_pro(int a)
    {
    printf("Hello, kaito!\n");
    return ;
    }

    void main()
    {
    pid_t kpid1 = 0xffff, kpid2 = 0xffff, pro1 = 0, pro2 = 0;
    if(kpid1 != 0 && kpid2 != 0)
    {
    kpid1 = fork();
    }
    if(kpid1 != 0 && kpid2 != 0)
    {
    kpid2 = fork();
    }
    if(kpid1 != 0 && kpid2 != 0)
    {
    pro1 = kpid1;
    pro2 = kpid2;
    waitpid(kpid1, NULL, 0);
    waitpid(kpid2, NULL, 0);
    exit(0);
    }
    if(kpid1 == 0)
    {
    char p[100];
    printf("Please input something:");
    scanf("%s", p);
    kill(pro2, SIGINT);
    exit(0);
    }
    if(kpid2 == 0)
    {
    signal(SIGINT, int_pro);
    pause();
    exit(0);
    }
    }

    接下来,我又写了一个创建用户输入个数进程的
    #include "klib.h"

    void multi_pro(int n)
    {
    int i = 0, flag = ~0x0;
    pid_t pid[n];
    memset(pid, 1, sizeof(pid));
    for(i = 0; i < n; i++)
    {
    if((pid[i] & flag) != 0)
    {
    pid[i] = fork();
    flag &= pid[i];
    }
    }
    for(i = 0; i < n; i++)
    {
    if(pid[i] == 0)
    {
    pause();
    exit(0);
    }
    }
    }

    void main()
    {
    int n = 0;
    while(1)
    {
    printf("Please input the number of processes that you want to create:");
    scanf("%d", &n);
    multi_pro(n);
    }
    }
    通过在中断输入Ctrl + C则可以发送SIGINT信号,最后会删除所有创建的子进程。这里用的方法就是在父进程标记一个flag,且始终保持它不为0。在任意子进程创建时,及时更新flag的值,若在父进程中,相与得非0;在子进程中相与得0,则在if判断中加上flag标志就可以区分出当前位置是父进程还是子进程。

    如果需要用到信号(signal)在两个子进程中进行信号传递,则可以事先在if判断外面定义一个pid_t类型的变量来保存各个子进程的pid,则可以用kill发送信号。

    最后贴一个创建进程执行文件的操作(shell使用的基本方式,只不过这里没有用argc和argv)
    #include "klib.h"
    pid_t src_pid;

    void create_pro(int a)
    {
    pid_t tmp_pro;
    tmp_pro = fork();
    if(tmp_pro == 0)
    {
    if(a == 1)
    {
    execv("./hello_kaito", NULL);
    exit(0);
    }
    if(a == 2)
    {
    execv("./hello_lily", NULL);
    exit(0);
    }
    }
    else
    {
    wait(NULL);
    }
    }

    void main()
    {
    int n;
    pid_t pid;
    src_pid = getpid();
    while(1)
    {
    printf("[1]say hello to kaito\n");
    printf("[2]say hello to Lily\n");
    scanf("%d", &n);
    if(n == 1)
    create_pro(1);
    if(n == 2)
    create_pro(2);
    }
    }
    展开全文
  • 个父进程创建多个子进程

    千次阅读 2018-08-07 20:59:49
    循环方式 #include #include #include #include ...#define child 10 ...int main(int argc, char const *argv[]) ... ++i)//创建子进程数 ... //如果在此位置,就是一个父进程创建多个子进程 } }  

    循环方式

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    
    #define child 10
    
    int main(int argc, char const *argv[])
    {   
    	pid_t pid;
     
        for (int i = 0; i < child; ++i)//创建子进程个数
        {
        	if (pid=fork()==0)//判断是否为子进程
        	{
        		printf("子进程%d:%d\n",i+1,getpid());
        		return 0;//结束子进程
        	}
        	waitpid(pid,NULL,WUNTRACED);//等待当前子进程结束
        }
        printf("\n");
        printf("父进程:%d\n",getpid());
    
    	return 0;
    }

    递归方式

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    
    #define child 5//宏定义子进程个数
    
    int child_child(int n);
    
    int main(int argc, char const *argv[])
    {
        //pid_t pid;
        child_child(child);
    	return 0;
    }
    
    int child_child(int n)
    {
    	if (n<=0)//设置跳出函数条件
    	{
    		return 0;
    	}
    	else
    	{   
    		pid_t pid = fork();//创建子进程
     
    		if (pid == 0)//判断是否是子进程
    		{
    			printf("子进程%d:%d\n",child-n+1,getpid());
    			//child_child(n-1);
    			//如果在此位置,就是子进程创建子进程
    			return 0;
    		}
    		waitpid(pid,NULL,WUNTRACED);
    		//child_child(n-1);
    		//如果在此位置,就是一个父进程创建多个子进程
    	}
    }

     

    展开全文
  • 一、内容 任务: 10个子进程求和问题。用套接进行父子进程间数据的通信。...所以我们用一信号量进行同步,子进程投入运行首先请求这信号量,而父进程完成准备工作才释放这信号量。 要注意...
  • 父进程创建子进程后,父进程与子进程同时执行(并发)。 主程序调用子程序后,主程序暂停在调用点,子程序开始执行,直到子程序返回,主程序开始执行。 我们可以这么理解:父进程运行的程序,创建了子进程,此时父...
  • Linux 进程家族数 生成三个子进程不生成...如果父进程需要创建3 子进程,但不创建孙子进程。请编写程序,并画出进程家族树。 (进程家庭树中填写进程 PID,使用 getpid, getppid)。 2. 分析 2.1 getpid、getppid g...
  • 假设是a进程创建了b进程,那么a进程就是b进程的父进程。 关于资源:子进程得到的是除了代码段是与父进程共享的意外,其他所有的都是得到父进程的一副本,子进程的所有资源都继承父进程,得到父进程资源的副本。 2...
  • 由于程序的需要,我们需要在一台服务器上启动多相似的子进程,如何做呢? 有种可以尝试一下: 1.循环创建: #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <...
  • 编写一段程序,使用系统调用fork()创建两个子进程。当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示“a“;子进程分别显示字符”b“和字符“c”。试观察记录...
  • 利用fork创建两个子进程的框架: #include #include #include void main() { int id = 1; while(1) { if(fork()) { if(id>2) //循环创建两个子进程 { break; } continue; } else
  • #include "apue.h" int main(void) { int n; int fd[2]; pid_t pid; char line[MAXLINE]; if(pipe(fd)&lt;0) err_sys("pipe error"); if((pid = fork())&...else if...
  • 子进程是父进程的一完全拷贝,如何理解?为什么fork创建子进程后,父进程中运行过的代码在子进程中不再运行了?
  • 2、编写一段程序,使用系统调用函数fork( )创建两个子进程,再用系统调用函数signal( )让父进程捕捉信号SIGINT(用kill命令来触发),当捕捉到中断信号后,父进程用系统调用函数kill( )向两个子进程发出信号,子进程...
  • Python中进程创建种方式

    千次阅读 2017-07-05 22:24:31
    博客核心内容:1、Python中进程创建种方式
  • #include #include #include int main() { pid_t pid; int i; for(i=0; i; i++) { pid=fork(); if(pid==0||pid==-1) //子进程创建进程失败均退出,这里是关键所在 { break;
  • Linux——进程创建和进程终止

    千次阅读 2021-03-15 21:05:48
    fork函数,从已存在进程中创建新进程,新进程为子进程,而原进程为父进程 进程调用fork,当控制转移到内核中的fork代码后,内核会做如下几件事: 分配新的内存块和内核数据结构给子进程 将父进程部分数据结构...
  • 4.父进程和子进程

    万次阅读 多人点赞 2018-05-19 17:36:10
    父进程和子进程 子进程是父进程的复制品Unix/linux系统中的进程创建是这样的,理解起来有点绕。父进程先执行fork()系统调用,这个调用...前后两个进程各自有自己的地址空间,形式上有点像把一个文件拷贝了一个副本...
  • 进程创建进程创建被定义为通过父进程创建子进程的过程。fork函数函数原型:pid_t fork(void);特点: 1.fork函数调用一次,返回次返回值得区别分别是子进程当中的返回值为0,父进程当中的返回值为新建子进程...
  • Linux父进程对于子进程的异步等待

    千次阅读 2017-06-27 16:59:27
    系统自己建立一个init进程,这是Linux系统的基础进程,然后init进程再根据一些配置文件决定创建哪些进程,或者我们在终端自己创建一个新进程的时候,如果你有时间,你可以一直追查这个进程的祖祖辈辈,你会发现,...
  • 父进程fork()次之后,产生了个子进程,父进程向管道里写数据,子进程读取,个子进程都能读取到还是先运行的那个可以读取到。 代码如下: 结果如下:  所以可见,只有一个子进程可以获得管道内的数据,...
  • 假定父进程malloc的指针指向0x12345678, fork 后,子进程中的指针也是指向0x12345678,但是这两个地址都是虚拟内存地址 (virtual memory),经过内存地址转换后所对应的 物理地址是不一样的。所以两个进城中的这两个...
  • LINUX父进程与子进程的理解

    千次阅读 2020-02-10 17:06:44
    除了进程0以外的所有进程都是由其他进程使用系统调用fork创建的,这里调用fork创建新进程的进程即为父进程,而相对应的为其创建出的进程则为子进程,因而除了进程0以外的进程都只有一个父进程,但一个进程可以有多...
  • 父进程与子进程

    千次阅读 2016-04-02 16:21:38
    关于父进程与子进程有许多疑问,这篇仅仅是开头,这系列仅为自己思考,并不是成熟体系,希望大家多批评指正。 在网上搜了很多,但是都没有一普适的解释,仅仅是what和how,而我想知道的是why,所以我自己决定...
  • 前一阵子遇到了这么一问题,父进程创建了子进程,然后父进程退出。 子进程第一件事卸载sdcard,结果提示设备资源忙。在子进程中使用fuser命令查 看sdcard挂载目录,结果发现子进程的确占用了该目录, 马上就明白...
  • fork出的子进程和父进程

    万次阅读 多人点赞 2013-10-31 16:43:56
    一、fork后的父子进程 ...将子进程id返回给父进程的理由是:因为一个进程的子进程可以多于一个,没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说,之所以fork返回0给它,是因为它随时可以调用
  • 方法1 先输出主进程,再输出子进程是因为 p.start() 只是给系统发送就绪...from multiprocessing import Process # 创建进程的模块 def task(name): print(name) if __name__ == '__main__': # 开启子进程 ...
  • 进程创建创建进程种方式

    万次阅读 2018-07-11 15:13:37
    一:进程的创建 1,系统的初始化 2,一个进程在运行过程中开启了子进程 3,用户的交互式请求,而创建一个新进程(如双击qq) 4,一个批处理作业的初始化(只在大型机的批处理系统中应用) 关于进程的创建,UNIX...
  • {//关闭父进程 close(fd[0]); close(fd[1]); // write(fd[1],buf,strlen(buf)); exit(0); } else   { close(fd[1]); len=read(fd[0],buf,BUFSIZE); if(len) err_quit(...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,368
精华内容 63,347
关键字:

父进程创建两个子进程