Linux系统应用编程---进程原语（fork、exec、wait&waitpid）

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <unistd.h>
4. 
5. int main(void)
6. {     
7. //fork创建一个新进程
8.        pid_t p1 = -1;
9. 
10. //fork之前的操作只有父父进程才有
11.        p1 = fork();    //调用一次fork函数会返回两次
12. 
13. if(p1 == 0)
14.        {
15. //这里一定是子进程
16. //先sleep一下，让父进程先死
17.               sleep(1);
18. 
19.               printf("子进程, pid = %d.\n", getpid());
20.               printf("子进程, p1 = %d.\n", p1);
21.               printf("子进程中父进程的ID = %d.\n", getppid());
22.        }
23. if(p1 > 0)
24.        {
25. //这里一定是父进程
26.               printf("父进程, pid = %d.\n", getpid());
27.               printf("父进程, p1 = %d.\n", p1);
28.        }
29. 
30. if(p1 < 0)
31.        {
32. 
33. //这里一定是出错了
34.        }
35. 
36. //在这里的操作，父子进程都有
37. //printf("hello world, pid = %d.\n", getpid());
38. 
39. return 0;
40. }

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
4. #include <sys/types.h>
5. 
6. int main(void)
7. {
8.        pid_t pid ;
9. //调用一次返回2次，在父进程返回子进程的PID，在子进程中返回0
10. 
11.        int n = 10;
12.        pid = fork();
13. 
14. if(pid > 0)
15.        {/*in parent*/
16.               while(1)
17.               {
18.                      printf("I am parent %d\n", n++);
19.                      printf("my pid = %d.\n", getpid());
20.                      printf("my parent pid = %d.\n", getppid());
21.                      sleep(1);
22.               }
23.        }
24. 
25. else if(pid == 0)
26.        {/*in child*/
27.               while(1)
28.               {
29.                      printf("I am child %d\n", n++);
30.                      printf("my pid = %d.\n", getpid());
31.                      printf("my parent pid = %d.\n", getppid());
32.                      sleep(3);
33. 
34.               }
35.        }
36. 
37. else
38.        {
39.               perror("fork");
40. exit(0);
41.        }
42. 
43. return 0;
44. }

1. #include <unistd.h>
2. 
3. int execl(const char *path, const char *arg, ...);
4. 
5. int execlp(const char *file, const char *arg, ...);
6. 
7. int execle(const char *path, const char *arg, ..., char *const envp[]);
8. 
9. int execv(const char *path, char *const argv[]);
10. 
11. int execvp(const char *file, char *const argv[]);
12. 
13. int execve(const char *path, char *const argv[], char *const envp[]);

1. #include <stdio.h>
2. #include <unistd.h>
3. 
4. 
5. int main(void)
6. {
7. printf("hello.\n");
8. execl("/bin/ls", "ls", "-l", NULL);
9. printf("world.\n");
10. return 0;
11. }

1. #include <sys/types.h>
2. 
3. #include <sys/wait.h>
4. 
5. pid_t wait(int *status);
6. 
7. pid_t waitpid(pid_t pid, int *status, int options);

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
4. #include <sys/types.h>
5. #include <wait.h>
6. 
7. int main(void)
8. {
9.        pid_t pid, pid_c;
10. //调用一次返回2次，在父进程返回子进程的PID，在子进程中返回0
11. 
12.        int n = 10;
13.        pid = fork();
14. 
15. if(pid > 0)
16.        {/*in parent*/
17.               while(1)
18.               {
19.                      printf("I am parent pid = %d\n", getpid());
20.                      pid_c = wait(NULL);            //wait是一个阻塞函数，等待回收子进程资源
21. 
22. //如果没有子进程，wait返回-1
23.                      printf("wait for child %d.\n", pid_c);
24.                      sleep(1);
25.               }
26.        }
27. 
28. else if(pid == 0)
29.        {/*in child*/
30. //printf("I am child %d\n", n++);
31.               printf("I am child pid = %d.\n", getpid());
32. //printf("my parent pid = %d.\n", getppid());
33.               sleep(10);
34.        }
35. 
36. else
37.        {
38.               perror("fork");
39. exit(0);
40.        }
41. 
42. return 0;
43. }

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <unistd.h>
4. #include <wait.h>
5. 
6. 
7. int main(void)
8. {
9. 
10.        pid_t pid;
11. 
12.        int n = 3;
13. 
14.        while(n--)
15.        {
16.               pid = fork();
17. if(pid == 0) break;
18.        }
19. 
20. if(pid == 0)
21.        {
22. //while(1)
23.               {
24.                      printf("I am child %d.\n", getpid());
25.                      sleep(3);
26.               }
27.        }
28. 
29. else if(pid > 0)
30.        {
31. 
32.               pid_t pid_c;
33.               while(1){
34. 
35. //pid_c = wait(NULL);
36.                      printf("I am parent.\n");
37.                      pid_c = waitpid(0, NULL, WNOHANG);
38. 
39. if(pid_c == -1)     
40. continue;
41. else
42.                             printf("wait for child %d.\n", pid_c);
43. if(pid_c > 0){
44.                             n++;     
45.                      }
46. if(n == 2)
47.                             break;                  
48.                      sleep(1);
49.               }
50.        }
51. 
52. return 0;
53. }