linux进程处理

1.测试这样没意义，要向后加
wait等待进程竣事
1.

2.测试
发送非常竣事的信号，通过kill

二、子进程的采取
    对于子进程的竣事而言，都希望父进程能够知道并作出肯定的反应，通过 wait、waitpid 函数可以知道子进程是如何竣事的以及它的竣事状态码
    pid_t wait(int *status);
    功能：等待子进程竣事，并获取竣事状态码
    status：输出型参数，吸收竣事状态码
    返回值：竣事的子进程的ID
        1、如果全部子进程都还在运行，则壅闭
        2、如果有一个子进程竣事，立即返回该进程的竣事状态码和ID
        3、如果没有子进程返回-1
    WIFEXITED(status)
        判定进程是否是正常竣事，如果是返回真
    WEXITSTATUS(status)
        如果进程是正常竣事的，可以获取到准确的竣事状态码
    WIFSIGNALED(status)
        判定进程是否非常竣事，如果是返回真
    WTERMSIG(status)
        如果进程是非常竣事的，可以获取到杀死进程的信号
    
    pid_t waitpid(pid_t pid, int *status, int options);
    功能：等待采取指定的某个或某些进程
    pid：
        >0  等待该进程竣事
        0   等待同组的恣意进程竣事
        -1  等待恣意进程竣事，功能与wait等价
        <-1 等待abs(pid) 进程组中的恣意进程竣事
    status：输出型参数，吸收竣事状态码
    options：
        WNOHANG 非壅闭模式，如果当前没有子进程竣事，则立即返回0
        WUNTRACED 如果有子进程处于暂停态，返回该进程的状态
        WCONTINUED  如果有子进程从暂停态转为继续运行，返回该子进程的状态
    WIFSTOPPED(status)
        判定子进程是否转为暂停态，是返回真
    WSTOPSIG(status)
        获取导致子进程进入暂停态的信号
    WIFCONTINUED(status)
        判定子进程是否由暂停转为继续，是返回真
    int system(const char *command);
    功能：通过创建子进程去执行一个可执行文件
    返回值：子进程竣事后才返回
    注意：该函数底层调用了fork、vfork、exec、waitpid函数

1. #include <stdio.h>
2. #include<unistd.h>
3. #include<sys/wait.h>
4. #include<stdlib.h>
5. #include<sys/types.h>
6. #include<signal.h>
7. //父进程收到信号会进来
8. void sigchld(int num)
9. {
10.         //子进程结束的时候父进程会接收到SIGCHLD信号，就会进入注册的处理函数
11.         int status=0;
12.         pid_t pid =wait(&status);
13.         printf("进程%d结束",pid);
14.         //if(pid==-1) exit(0); //无效
15.         if( WIFEXITED(status))
16.         {
17.                 printf("是正常结束的，状态码是%d\n",   WEXITSTATUS(status));
18.                
19.                 }
20.                 else{
21.                         printf("该进程异常结束,被%d信号杀死", WTERMSIG(status));
22.                        
23.         }
24.        
25. }
30. int main(int argc,const char* argv[])
31. {
32.         signal(SIGCHLD,sigchld);
33.         for(int i=0;i<10;i++)
34.         {
35.                 if(0==fork())
36.                 {
37.                         srand(i);
38.                         printf("这是子进程%u i=%d\n",getpid(),i);
39.                         sleep(rand()%8+3);//0-10
40.                         if(i%2) kill(getpid(),9);//发信号当前信号，9        向当前进程发出异异常结束
41.                         return i;
42.                 }
43.                 sleep(1);//防止信号还没来的及处理
44.         }
45.         for(;;)
46.         {
47.                 //父进程自己在干事情
48.                 printf("*");//在缓冲区中????
49.                 fflush(stdout);//刷新缓冲区
50.                 sleep(1);
51.                
52.                 /*
53.                 int status=-1;
54.                 pid_t pid=wait(&status);
55.                 if(-1==pid) break;
56.                 printf("子进程%d结束了，status=%d\n",pid,status);
57.         if( WIFEXITED(status))
58.         {
59.                 printf("是正常结束的，状态码是%d\n",   WEXITSTATUS(status));
60.                
61.                 }
62.                 else{
63.                         printf("该进程异常结束,被%d信号杀死", WTERMSIG(status));
64.                        
65.         }*/
66.         }
67.         printf("没有了子进程\n");
68.         return 0;
69. }

复制代码

2.

1. #include <stdio.h>
2. #include<unistd.h>
3. #include<sys/wait.h>
4. #include<stdlib.h>
5. #include<sys/types.h>
6. #include<signal.h>
7. /*
8. //父进程收到信号会进来
9. void sigchld(int num)
10. {
11.         //子进程结束的时候父进程会接收到SIGCHLD信号，就会进入注册的处理函数
12.         int status=0;
13.         pid_t pid =wait(&status);
14.         printf("进程%d结束",pid);
15.         //if(pid==-1) exit(0); //无效
16.         if( WIFEXITED(status))
17.         {
18.                 printf("是正常结束的，状态码是%d\n",   WEXITSTATUS(status));
19.                
20.                 }
21.                 else{
22.                         printf("该进程异常结束,被%d信号杀死", WTERMSIG(status));
23.                        
24.         }
25.        
26. }*/
31. int main(int argc,const char* argv[])
32. {
33.   //        signal(SIGCHLD,sigchld);
34.         for(int i=0;i<10;i++)
35.         {
36.                 if(0==fork())
37.                 {
38.                         srand(i);
39.                         printf("这是子进程%u 父进程%u i=%d\n",getpid(),getppid(),i);
40.                         sleep(rand()%8+3);//0-10
41.                         if(i%2)
42.                         {
43.                                 exit(i);//发信号当前信号，9        向当前进程发出异异常结束
44.                         }
45.                         else
46.                         {
47.                                 kill(getpid(),20);       
48.                         }
49.                 //        return i;
50.                 }
51.                 sleep(1);//防止信号还没来的及处理
52.         }
53.         for(;;)
54.         {
55.                 //父进程自己在干事情
56.                 printf("*");//在缓冲区中????
57.                 fflush(stdout);//刷新缓冲区
58.                
59.                
60.                
61.                 int status=-1;
62.                 pid_t pid=waitpid(0,&status,WNOHANG |WUNTRACED |WCONTINUED );
63.                
64.                
65.         if(pid>0)
66.         {
67.                 if( WIFSTOPPED(status))
68.                 {
69.                 printf("子进程%d进暂停，导致的信号%d\n",pid,   WSTOPSIG(status));
70.                
71.                 }
72.                 else if( WIFCONTINUED(status))
73.                 {
74.                         printf("子进%d程有暂停转为继续运行", pid);
75.                        
76.                 }
77.                 else
78.                 {
79.                         printf("子进程%d结束,status=%d\n",pid,   WEXITSTATUS(status));       
80.                 }
81.         }
82.         sleep(1);
83.        
84. }return 0;
85. }

复制代码

3.

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。