Linux下进程控制实验

 （1）fork（）创建子进程

 

1. #include <unistd.h> 
2. #include <sys/types.h> 
3. #include <sys/wait.h> 
4. #include <stdio.h> 
5. #include <stdlib.h> 
6. #include <errno.h> 
7. #include <math.h> 
8.  
9. /* 进程创建 */ 
10. void main(void) 
11. { 
12.     pid_t child; 
13.     int status; 
14.  
15.     printf("This will demostrate how to get child status\n"); 
16.  
17.     /* 创建子进程 */ 
18.     if((child=fork())==-1) 
19.     { 
20.         printf("Fork Error : %s\n", strerror(errno)); 
21.         exit(1); 
22.     } 
23.     else if(child==0) // 子进程 
24.     { 
25.         int i; 
26.         printf("I am the child: %s\n", getpid()); 
27.         for(i=0;i<1000000;i++) sin(i); 
28.         i=5; 
29.         printf("I exit with %d\n", i); 
30.         exit(i); 
31.     } 
32.  
33.     while(((child=wait(&status))==-1)&(errno==EINTR));  //子进程未结束 
34.  
35.     if(child==-1) 
36.         printf("Wait Error: %s\n", strerror(errno)); 
37.     else if(!status)             // 子进程退出值为0 
38.         printf("Child %ld terminated normally return status is zero\n", child); 
39.     else if(WIFEXITED(status))   // 子进程退出值0 
40.         printf("Child %ld terminated normally return status is %d\n", child, WEXITSTATUS(status)); 
41.     else if(WIFSIGNALED(status)) // 子进程未获信号而退出 
42.         printf("Chlid %ld terminated due to signal %d not caught\n", child, WTERMSIG(status)); 
43. }    

(2）进程等待waitpid（）

 

1. #include <stdio.h> 
2. #include <stdlib.h> 
3. #include <sys/types.h> 
4. #include <unistd.h> 
5. #include <sys/wait.h> 
6.  
7. void die(const char *msg) 
8. { 
9.         perror(msg); 
10.         exit(1); 
11. } 
12.  
13. void child2_do() 
14. { 
15.         printf("In child2: execute 'date'\n"); 
16.  
17.         sleep(5); 
18.         if (execlp("date", "date", NULL) < 0) { 
19.                 perror("child2 execlp"); 
20.         } 
21. } 
22.  
23. void child1_do(pid_t child2, char *argv) 
24. { 
25.         pid_t pw; 
26.  
27.         do { 
28.                 if (*argv == '1') { 
29.                         pw = waitpid(child2, NULL, 0); 
30.                 } 
31.                 else { 
32.                         pw = waitpid(child2, NULL, WNOHANG); 
33.                 } 
34.                 if (pw == 0) { 
35.                         printf("In child1 process:\nThe child2 process has not exited!\n"); 
36.                         sleep(1); 
37.                 } 
38.         }while (pw == 0); 
39.  
40.         if (pw == child2) { 
41.                 printf("Get child2 %d.\n", pw); 
42.                 sleep(5); 
43.                 if (execlp("pwd", "pwd", NULL) < 0) { 
44.                         perror("child1 execlp"); 
45.                 } 
46.         } 
47.         else { 
48.                 printf("error occured!\n"); 
49.         } 
50. } 
51.  
52. void father_do(pid_t child1, char *argv) 
53. { 
54.         pid_t pw; 
55.  
56.         do { 
57.                 if (*argv == '1') { 
58.                         pw = waitpid(child1, NULL, 0); 
59.                 } 
60.                 else { 
61.                         pw = waitpid(child1, NULL, WNOHANG); 
62.                 } 
63.  
64.                 if (pw == 0) { 
65.                         printf("In father process:\nThe child1 process has not exited.\n"); 
66.                         sleep(1); 
67.                 } 
68.         }while (pw == 0); 
69.  
70.         if (pw == child1) { 
71.                 printf("Get child1 %d.\n", pw); 
72.                 if (execlp("ls", "ls", "-l", NULL) < 0) { 
73.                         perror("father execlp"); 
74.                 } 
75.         } 
76.         else { 
77.                 printf("error occured!\n"); 
78.         } 
79. } 
80.  
81. int main(int argc, char *argv[]) 
82. { 
83.         pid_t child1, child2; 
84.  
85.         if (argc < 3) { 
86.                 printf("Usage: waitpid [0 1] [0 1]\n"); 
87.                 exit(1); 
88.         } 
89.  
90.         child1 = fork(); 
91.  
92.         if (child1 < 0) { 
93.                 die("child1 fork"); 
94.         } 
95.         else if (child1 == 0) { 
96.                 child2 = fork(); 
97.  
98.                 if (child2 < 0) { 
99.                         die("child2 fork"); 
100.                 } 
101.                 else if (child2 == 0) { 
102.                         child2_do(); 
103.                 } 
104.                 else { 
105.                         child1_do(child2, argv[1]); 
106.                 } 
107.         } 
108.         else { 
109.                 father_do(child1, argv[2]); 
110.         } 
111.  
112.         return 0; 
113. } 

 

（3）结束进程函数 kill（）

 

1. #include <sys/wait.h> 
2. #include <sys/types.h> 
3. #include <stdio.h> 
4. #include <stdlib.h> 
5. #include <signal.h> 
6.  
7. int main( void ) 
8. { 
9.     pid_t childpid; 
10.     int status; 
11.     int retval; 
12.      
13.     childpid = fork(); 
14.     if ( -1 == childpid ) 
15.     { 
16.         perror( "fork()" ); 
17.         exit( EXIT_FAILURE ); 
18.     } 
19.     else if ( 0 == childpid ) 
20.     { 
21.         puts( "In child process" ); 
22.         sleep( 100 );//让子进程睡眠，看看父进程的行为 
23.         exit(EXIT_SUCCESS); 
24.     } 
25.     else  
26.     { 
27.         if ( 0 == (waitpid( childpid, &status, WNOHANG ))) 
28.         { 
29.             retval = kill( childpid,SIGKILL ); 
30.              
31.             if ( retval ) 
32.             { 
33.                 puts( "kill failed." ); 
34.                 perror( "kill" ); 
35.                 waitpid( childpid, &status, 0 ); 
36.             } 
37.             else 
38.             { 
39.                 printf( "%d killed\n", childpid ); 
40.             } 
41.              
42.         } 
43.     } 
44.      
45.     exit(EXIT_SUCCESS); 
46. }     

 

转载于:https://blog.51cto.com/6386296/1120823