Linux4 进程复制

一、printf 函数输出问题

        printf 函数并不会直接将数据输出到屏幕，而是先放到缓冲区中，只有一下三种情况满足，才会输出到屏幕。

        1） 缓冲区满

        2） 强制刷新缓冲区 fflush

        3） 程序结束时

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. int main(int argc, char* argv[],char* envp[])
5. {
6. printf("hello");
7. //fflush(stdout);
8. sleep(3);
9. exit(0);
10. }

这段代码使用fflush和sleep来更清晰的显示出缓冲区的存在。

二、主函数参数介绍

        int main( int argc, char* argv[], char* envp[])

        (1) argc 参数个数

        (2) argv 参数内容

        (3) envp 环境变量

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <assert.h>
6.
7. //参数个数 参数内容 环境变量
8. int main(int argc, char* argv[],char* envp[])
9. {
10. int i = 0;
11. printf("argc=%d\n",argc);
12.
13. for( ;i < argc; i++ )
14. {
15. printf("argv[%d]=%s\n",i,argv[i]);
16. }
17.
18. for( i = 0; envp[i] != NULL; i++ )
19. {
20. printf("envp[%d]=%s\n",i,envp[i]);
21. }
22. exit(0);
23. }

代码执行结果：

三、复制进程 fork

3.1 fork 方法

pid_t fork(void)；

函数返回类型 pid_t 实质是 int 类型，Linux 内核 2.4.0 版本的定义是：

fork 函数会新生成一个进程，调用 fork 函数的进程为父进程，新生成的进程为子进程。 在父进程中返回子进程的 pid，在子进程中返回 0，失败返回-1。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <assert.h>
6.
7. int main(int argc, char* argv[],char* envp[])
8. {
9. char * s = NULL;
10. int n = 0;
11.
12. pid_t pid = fork();
13. assert( pid != -1 );
14.
15. if ( pid == 0 )
16. {
17. s = "child";
18. n = 4;
19. }
20. else
21. {
22. s = "parent";
23. n = 7;
24. }
25.
26. int i = 0;
27.
28. for(; i < n; i++ )
29. {
30. printf("pid=%d,n=%d,&n=%x,s=%s\n",getpid(),n,&n,s);
31. sleep(1);
32. }
33.
34. exit(0);
35. }

3.2 fork 练习

下列程序输出几个“A”？

代码一：

1. int main(int argc, char* argv[],char* envp[])
2. {
3. int i = 0;
4. for( ; i < 2; i++ )
5. {
6. fork();
7. printf("A\n");
8. }
9. exit(0);
10. }

代码二：

1. int main(int argc, char* argv[],char* envp[])
2. {
3. int i = 0;
4. for( ; i < 2; i++ )
5. {
6. fork();
7. printf("A");
8. }
9. exit(0);
10. }

代码一

1. fork() 被调用了两次，每次调用后都会打印 “A\n”。
2. 每次调用 fork() 都会使得进程数量翻倍。
3. 所以，总共有 2^2 = 422=4 个进程，每个进程都会打印 “A\n”。

代码二

1. 与代码一类似，fork() 被调用了两次。
2. 但是，这里没有换行符，所以所有进程的输出可能会混合在一起。
3. 总共有 2^2 = 422=4 个进程，每个进程都会打印 “A”。