Linux 进程知识 函数fork的使用

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
int main(int argc,char** argv)
{
        pid_t pid;
        printf("[%d]begin\n",getpid());
        pid=fork();
        if(pid<0)
        {
                perror("fork()");
        }
        else if(pid==0)
        {
                printf("[%d]child process is working!\n",getpid());
        }
        else
        {
                printf("[%d]father process is working!\n",getpid());
        }
        exit(0);
}

结果：

[19790]begin
[19790]father process is working!
[19791]child process is working!

重定向到/tmp/out  begin打印了两次，原因是文件是全缓冲模式，缓冲区的begin也被fork复制过去，子进程和父进程都打印了。

book@100ask:~/tmpfile/process_basic$ cat /tmp/out
[19792]begin
[19792]father process is working!
[19792]begin
[19793]child process is working!

解决方案：在fork之前刷新所需要的流，刷新缓存区内容.

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
int main(int argc,char** argv)
{
        pid_t pid;
        printf("[%d]begin\n",getpid());
        fflush(NULL);
        pid=fork();
        if(pid<0)
        {
                perror("fork()");
        }
        else if(pid==0)
        {
                printf("[%d]child process is working!\n",getpid());
        }
        else
        {
                printf("[%d]father process is working!\n",getpid());
        }
        exit(0);
}

~

 结果：符合预期，begin只在父进程打印一次

book@100ask:~/tmpfile/process_basic$ ./fork0 > /tmp/out
book@100ask:~/tmpfile/process_basic$ cat /tmp/out
[19821]begin
[19821]father process is working!
[19822]child process is working!

 一个进程判断质数并打印出来

#include<unistd.h>
#include<sys/types.h>
#define LEFTNUM 3000000
#define RIGHTNUM 3000200
int main(int argc,char** argv)
{
        int mark=0;
        for(int i=LEFTNUM;i<=RIGHTNUM;i++)
        {
                mark=1;
                for(int j=2;j<i/2;j++)
                {
                        if(i%j==0)
                        {
                                mark=0;
                                break;
                        }
                }
                if(mark==1)
                {
                        printf("%d is a primer!\n",i);
                }
        }
        exit(0);
}

结果： 。/fork1 |wc -l可以得到有几行打印（即有几个质数）

book@100ask:~/tmpfile/process_basic$ make fork1
cc     fork1.c   -o fork1
book@100ask:~/tmpfile/process_basic$ ./fork1
3000017 is a primer!
3000029 is a primer!
3000047 is a primer!
3000061 is a primer!
3000073 is a primer!
3000077 is a primer!
3000089 is a primer!
3000103 is a primer!
3000131 is a primer!
3000133 is a primer!
3000161 is a primer!
3000181 is a primer!
3000199 is a primer!
book@100ask:~/tmpfile/process_basic$ ./fork1 | wc -l
13

 一个进程求质数的时间：

 用子进程来判断是否为质数并打印：分为1个父进程和201个子进程

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#define LEFTNUM 3000000
#define RIGHTNUM 3000200
int main(int argc,char** argv)
{
        pid_t pid;
        int mark=0;
        for(int i=LEFTNUM;i<=RIGHTNUM;i++)
        {
                pid=fork();
                if(pid<0)
                {
                        perror("fork()");
                        exit(0);
                }
                //子进程
                else if(pid==0)
                {
                        mark=1;
                        for(int j=2;j<i/2;j++)
                        {
                                if(i%j==0)
                                {
                                        mark=0;
                                        break;
                                }
                        }
                        if(mark==1)
                        {
                                printf("%d is a primer!\n",i);
                        }
                        //跳出子进程，否则会开辟远大于201个子进程
                        exit(0);
                }

        }
        exit(0);
}

 结果： 对比可知运行时间缩短

book@100ask:~/tmpfile/process_basic$ time ./fork2 >/tmp/out

real    0m0.021s
user    0m0.000s
sys     0m0.020s

注意：子进程中要终止exit(0),否则子进程还会开辟心的子进程，则会多出预期计算的很多个子进程。如果父进程比子进程先结束，那么子进程变成“孤儿”，由init进程接管，init作为子进程的父进程。