操作系统fork()进程_fork进程

1、fork()是创建进程函数。

2、c程序一开始，就会产生 一个进程，当这个进程执行到fork()的时候，会创建一个子进程。

3、此时父进程和子进程是共存的，它们俩会一起向下执行c程序的代码。

4、需要注意！！！子进程创建成功后，fork是返回两个值，一个代表父进程，一个代表子进程：代表父进程的值是一串数字，这串数字是子进程的ID（地址）；一个代表子进程，值为0。

下面写一段代了解了解（注释很重要）

运行结果如下父进程printf出来的是子进程 的ID即那串数字，子进程printf的则为0：

深入学习

1-1.c

#include<unistd.h>
#include<stdio.h>
int main()
{
        int p1,p2;
        if(p1=fork())               /*子进程创建成功*/
                //父进程返回的是一串数字>1，满足条件,执行下面语句
           putchar('b');//首先输出b，之后该父进程自杀了（结束）
        else   //这里是由于子进程的fork为0，子进程在这里面执行
        {
                if(p2=fork())       //在这里子进程创建了自己的子进程（先凑合叫做孙进程吧），此时子进程fork返回孙进程的ID>1，则可以执行下面语句
                   putchar('c');//子进程执行，输出c
                else
                   putchar('a');           /*父进程执行*/
		//上面老师注释的父进程我认为是“孙进程”，而不是一开始的父进程，一开始的父进程putchar出b后，已经被杀死了，不信可以 printf("%d",p2);，看看是不是输出0,fork()为0，则为孙进程
        }
printf("\n");

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行结果（注意看代码注释，通俗点说就是父进程输出了b，子进程输出了c，孙进程输出a 。其实没有孙进程这种说法吧。）

1-2.c

#include<stdio.h> 
#include<sys/types.h>
#include<unistd.h> 
int main() 
{  
    int p1,p2;  
    while((p1=fork())==-1)//如果子进程创建失败则fork返回-1=-1，while循环不会跳出，直至创建成功，fork为子进程的ID或者0才可以跳出while循环
	printf("111");  //没有输出111.说明p1不等于-1，那说明子进程创建成功，直接跳出while循环
       // printf("%d\n",p1);     //父子进程都会执行这一句，谁先谁后是随机的，所以有可能先显示0再显示ID，否则反之
    if (p1==0)               //子进程的fork为0，满足此条件            
      putchar('b'); 	     //由子进程输出‘b’，接着子进程自杀
    else 		     //由于刚刚父进程不满足上面的if条件，所以来到else这下面执行
    {  
      while((p2=fork())==-1);  //重建子进程（第二个孩子）
      if (p2==0)             //第二个孩子满足fork=0  
       putchar('c'); 		//第二个孩子执行输出“c”
      else                   //父进程最终什么都不满足地来到这里
       {putchar('a');  	     //父进程输出“a”
	//printf("\n%d\n",p2);
	}
    } 
}//结果我猜正确的顺序是acb或者bac。这个要看父子进程的看快慢，就像赛跑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

执行结果

2-1.c

#include<stdio.h>
#include<unistd.h>
int main()
{
	int p1,p2,i;
	if(p1=fork())//此时父进程的fork为一串数字，子进程fork为0；父进程的fork>0，满足条件
 		for(i=0;i<5;i++)
		        printf("child %d\n",i);//说明创建进程成功，不管是男孩还是女孩
	else//子进程不满足上面if条件，从而来到这里
	{ 
 	if(p2=fork())//子进程来这里创建“孙”进程，此后子进程fork为一串数字即“孙”进程的ID；则孙进程的fork为0；子进程fork>0，满足条件
    		for(i=0;i<5;i++) 
			printf("son %d\n",i);
 	else//“孙”进程不满足上面if条件，从而来到这里
    		for(i=0;i<5;i++)  
			printf("daughter %d\n",i);//老师的理解和我的不一样吧。我认为这是子进程的子进程了，是个女儿。
	}
}

//输出结果的话，也是随机的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

执行结果：

2-2.c

/*
author：Szymou
explain：
lockf(1,1,0)是锁上资源让该进程独自享用
lockf(1,0,0)是解锁资源，给其他进程用
下面的sleep用于该进程“休息一下”，休息的时候，其他进程可以用资源
这里的资源是个人认为是磁盘的缓冲区buffer
*/
#include<stdio.h>
#include<unistd.h>
int main()//每次printf的时候，系统会先将需要输出的字符存在缓冲区buffer里面
{
	int p1,p2,i;
	if(p1=fork())
	{
     	lockf(1,1,0);//锁上buffer自己享用
     	for(i=0;i<3;i++)  
		{
		printf("child %d\n",i);
		/*老师的默认第二个lockf(1,1,0)是一直锁上的，结果会是先全部输出son012，再输出其他，其他进程同理*/
     	lockf(1,0,0);//解锁给另外的子进程  
     	sleep(2);//其他子进程可以在父进程休眠的时候调用buffer使用
     	}
	}
	else
 	{
  		if(p2=fork())
			{ 
			    lockf(1,1,0);//锁上buffer自己享用
     			for(i=0;i<3;i++)  
     			{
     			printf("son %d\n",i);
    			lockf(1,0,0);
    			sleep(2);
    			}
  			}
		else
		{ 
		    lockf(1,1,0);//锁上buffer自己享用     //运行结果>>>>>
     		for(i=0;i<3;i++)                    //运行结果>>>>>
     		{
     		printf("daughter %d\n",i);
   	 	    lockf(1,0,0);
   	 	    sleep(2);
   	 	    }
		}
	 }return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

运行结果：

3-1.c

/*
author：Szymou
explain：
父进程称为a进程
往下就是b、c、d进程
*/
#include<stdio.h>
#include<unistd.h>
int main()
 {
    int p1,p2,p3,p4;
    while((p1=fork())==-1);//a进程在这里创建b进程

    if(p1!=0)//父进程称为a进程，进来了
    {
     	printf("process a(its id=%d,its father pid is %d)\n",getpid(),getppid());
    }
    else//b进程进来了
    {
        printf("precess b(its id=%d,its father pid is %d)\n",getpid(),getppid());
        while((p2=fork())==-1) ;//b进程创建c进程

        if(p2==0)//c进程进来
        {
            printf("precess c(its id=%d,its father pid is %d)\n",getpid(),getppid());
            while((p3=fork())==-1) ;//c进程创建d进程

            if(p3==0)//d进程进来
            printf("precess d(its id=%d,its father pid is %d)\n",getpid(),getppid());
       }
    }
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

观察执行结果，会发现有些进程的父进程ID显示不是自己父进程的ID 这是因为其父进程死了，而她成了孤儿进程，被某进程收养了，所以显示的父进程ID是收养它的那个进程的ID，可以用命令ps
x查看当前进程，查找进程ID，即可明了。

应该怎么使得每个进程的父进程ID显示正确呢？
那就应该让该父进程别死，让它等待其子进程死后再死即可。这时候我们就应该使用一个函数了，这个函数是wait()。
作用是父进程执行到wait()，会被挂起来，等待其子进程结束后，自己才结束。

代码：

/*
author：Szymou
explain：
父进程称为a进程
往下就是b、c、d进程；
有一种情况：有些进程显示其父进程ID不是父进程ID，而是系统进程ID，这是因为父进程死后，子进程get不到父进程ID，从而成了孤儿，在乌班图下会被upstart收养，在CentOS下会被init收养。可以用ps x来查看；
wait()函数可以让当前父进程等待子进程结束，父进程才结束。这里引进这个函数，是因为，避免父进程死后，子进程没了爸爸，找不到爸爸的ID即getppid
*/

/*
    这两个头文件用于支持wait()函数
*/
#include <sys/types.h> 
#include <sys/wait.h>


#include<stdio.h>
#include<unistd.h>
int main()
 {
    int p1,p2,p3,p4;
    while((p1=fork())==-1);//a进程在这里创建b进程
    if(p1!=0)//父进程称为a进程，进来了
    {
     	printf("process a(its id=%d,its father pid is %d)\n",getpid(),getppid());
     	wait(NULL);
    }
    else//b进程进来了
    {
        printf("precess b(its id=%d,its father pid is %d)\n",getpid(),getppid());
        while((p2=fork())==-1) ;//b进程创建c进程
        if(p2!=0) wait(NULL);
	//sleep(1);
        else if(p2==0)//c进程进来
        {
            printf("precess c(its id=%d,its father pid is %d)\n",getpid(),getppid());
            while((p3=fork())==-1) ;//c进程创建d进程
            if(p3!=0) wait(NULL);
	    //sleep(1);
            else if(p3==0)//d进程进来
            printf("precess d(its id=%d,its father pid is %d)\n",getpid(),getppid());
       }
    }
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

运行结果（不再会出现孤儿进程现象）

有什么问题可以在评论区一起讨论哦！一起学