进程、僵死进程、孤儿进程、守护进程

分手后的思念是犯贱 2022-05-29 06:47 439阅读 0赞

# 进程 #

**1、进程标识**  
每个进程都有一个非负整数表示的进程ID。ID为0的是调用进程，也叫交换进程。ID为1的是init进程，内核自举启动后调用的第一个进程用于读取与系统初始化相关文件。ID为2的是页守护进程，负责支持虚拟存储系统的分页操作。

**2、fork函数**  
创建新的进程，调用一次返回两次。父进程返回子进程ID，子进程返回0，之后子进程和父进程继续执行fork之后的指令。子进程获取父进程的数据空间、堆、栈的副本。父子进程不共享这些存储空间，但是代码段（正文段，指令）是父子进程共享的，这点可以参考C程序内存空间布局，这个很重要哦。学习fork的写时拷贝技术。

**3、进程如何被创建**  
[采用写时拷贝技术][Link 1]

**4、进程和线程的区别**

*  进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元。
 *  同一个进程中可以包括多个线程，并且线程共享整个进程的资源（寄存器、堆栈、上下文除外），一个进行至少包括一个线程。
 *  进程的创建调用fork或者vfork，而线程的创建调用pthread\_create，进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束。
 *  线程是轻两级的进程，它的创建和销毁所需要的时间比进程小很多，所有操作系统中的执行功能都是创建线程去完成的。
 *  线程中执行时一般都要进行同步和互斥，因为他们共享同一进程的所有资源。
 *  线程有自己的私有属性TCB，线程id，寄存器、硬件上下文，而进程也有自己的私有属性进程控制块PCB，这些私有属性是不被共享的，用来标示一个进程或一个线程的标志。

**5、进程间通信方式**

*  管道（匿名管道（pipe亲缘关系的进程通信）、命名管道（mkfifo/mknod））
 *  消息队列：是基于消息的、用无亲缘关系的进程间通信，主要函数：msgget、msgsend、msgrecv、msgctl
 *  信号量：相当于一把互斥锁，通过p、v操作，主要函数：semget、semop、semctl
 *  共享内存：是进程间通信速度最快的，所以用经常是集合信号量或互斥锁来实现同步，shmget、shmat、shmdt、shmctl

**6、PS进程的状态**  
[通过ps查看进程状态][ps]

*  R（可运行状态）：即进程正在运行或在运行队列(可执行队列)中等待。运行和就绪都处于R。只有在该状态的进程才可能在CPU上运行，同一时刻可能有多个进程处于该状态。
 *  S（Interruptible sleep 可中断休眠状态）：即进程在休眠中，由于在等待某个事件的完成(或等待某个条件的形成或等待某个信号等)（例如等待socket连接、等待信号量等】而被挂起；当这些事件发生时，对应的等待队列中的一个或多个进程将被唤醒。一般情况下，进程列表中绝大多数进程都处于该状态。
 *  D（Uninterruptible sleep 不可中断休眠状态）：同步I/O在做读或写操作时，此进程不能做其他事情，只能等待；如果程序采用异步I/O，这种状态应该就很少被看见了。
 *  T（Stopped or Traced 停止状态）：处于暂停或跟踪状态。进程收到SIGSTOP、SIGSTP、SIGTIN、SIGTOU等信号进入暂停状态，或者正在被跟踪，“被跟踪”指进程暂停下来，等待跟踪它的进程对它进行操作。
 *  Z（僵死状态）：进程结束，放弃了几乎所有的内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置来记载该进程的退出状态等信息(task\_struct结构体（保存了该进程的退出码）供其他进程收集，只有其父进程通过waitpid获取后，内核才会清除这些信息。所以当子进程先与父进程结束，但父进程没有调用wait或waitpid来回收子进程的资源，所以子进程就成了僵尸进程，如果父进程结束后任然没有回收子进程的资源，那么就会造成比较多的资源浪费。

上面状态比较详细，可以将进程状态大体归纳为3种：运行态(R)、就绪态(R)、阻塞态(S、D、T、Z)。

*  运行：当一个进程在处理机上运行时，则称该进程处于运行状态。
 *  就绪：已经进入了可运行队列，而没有运行的进程，等待调度器调用占据CPU。
 *  阻塞：也称为等待或睡眠状态，一个进程正在等待某一事件发生（例如请求I/O而等待I/O完成等）而暂时停止运行，这时即使把处理机分配给进程也无法运行，故称该进程处于阻塞状态。  
    进程3种状态转换图：  
    ![这里写图片描述][70]

# 孤儿进程 #

一个其父进程已终止的进程称为孤儿进程，这种进程由init进程收养。孤儿进程绝对不会成为僵死进程。

# 僵死进程 #

## 1、介绍 ##

子进程在父进程之前终止了，内核为每个终止子进程保存了一定量的信息，所以父进程需要调用`waitpid`可以得到这些信息，包括进程ID、终止状态、使用的CPU时间总量，内核可以释放终止进程所使用的内存空间及其打开的文件描述符。**一个已经终止，但是其父进程尚未对其进行善后处理（获取信息，释放资源）的进程称为僵死进程**。通过ps命令，我们可以看到该进程的状态为Z(表示僵死)。fork很多子进程，除非父进程等待获取其终止状态，不然这些子进程都将在终止后成为僵死进程。 **注意由init进程收养的进程终止不会变成僵死进程，因为init默认只要其子进程终止，都会去调用wait函数取得其终止状态**。**Init子进程包括收养的孤儿进程和自己产生的子进程**。 僵死进程会占用大量的内存空间，一般情况下都不愿意留下僵死进程，从而需要使用一种避免产生僵死进程的方法。

int main(void)
    {
        pid_t child = fork();
        if( child < 0  ) {     //fork error.
            perror("fork process fail.\n");
        } else if( child ==0  ) {   // in child process
            printf(" fork succ, this run in child process\n ");
        } else {                        // in parent process
            printf(" this run in parent process\n ");
            sleep(600);
        }
        return 0;
    }

![这里写图片描述][Image 1]  
在子进程退出后，父进程还在运行，并且没有获取其状态并调用waitpid清理子进程空间，于是产生僵死进程Z。

## 2、避免产生僵死进程 ##

（1）fork子进程之后，我们调用wait清理他们，或者当子进程状态改变，内核都会给父进程一个SIGCHLD信号，可以在信号捕捉函数里面调用wait清理，这样子进程不会成为僵死进程。

但是上述方法会有一定的缺陷：

![这里写图片描述][Image 1]  
假设有一个client/server的程序，对于每一个连接过来的client，server都启动一个新的进程去处理来自这个client的请求。然后我们有一个client进程，在这个进程内，发起了多个到server的请求（假设5个），则server会fork 5个子进程来读取client输入并处理（同时，当客户端关闭套接字的时候，每个子进程都退出）；当我们终止这个client进程的时候 ，内核将自动关闭所有由这个client进程打开的套接字，那么由这个client进程发起的5个连接基本在同一时刻终止。这就引发了5个FIN，每个连接一个。server端接受到这5个FIN的时候，5个子进程基本在同一时刻终止。这就又导致差不多在同一时刻递交5个SIGCHLD信号给父进程。如上图。  
所有5个信号都在信号处理函数执行之前产生，**而信号处理函数只执行一次**，因为Unix信号一般是不排队的。更严重的是，问题是不确定的，依赖于客户FIN到达服务器主机的时机，信号处理函数执行的次数并不确定。**正确的解决办法是调用waitpid而不是wait**，这个办法的方法为：**信号处理函数中，在一个循环内调用waitpid，以获取所有已终止子进程的状态**。我们必须指定WNOHANG选项非阻塞，他告知waitpid在有尚未终止的子进程在运行时不要阻塞。

//server.c
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/socket.h>
    #include <errno.h>
    #include <error.h>
    #include <netinet/in.h>
    #include <netinet/ip.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <signal.h>
    #include <sys/wait.h>
    
    typedef void sigfunc(int);
    
    void func_wait(int signo) {
        pid_t pid;
        int stat;
        pid = wait(&stat);    
        printf( "child %d exit\n", pid );
        return;
    }
    void func_waitpid(int signo) {
    //这种处理方式就不会产生僵尸进程，waitpid全部处理了，如果没有子进程终止了，那么返回0或者-1。
        pid_t pid;
        int stat;
        while( (pid = waitpid(-1, &stat, WNOHANG)) > 0 ) {
            printf( "child %d exit\n", pid );
        }
        return;
    }
    
    sigfunc* signal( int signo, sigfunc *func ) {
        struct sigaction act, oact;
        act.sa_handler = func;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        if ( signo == SIGALRM ) {
    #ifdef SA_INTERRUPT
            act.sa_flags |= SA_INTERRUPT;    /* SunOS 4.x */
    #endif
        } else {
    #ifdef SA_RESTART
            act.sa_flags |= SA_RESTART;    /* SVR4, 4.4BSD */
    #endif
        }
        if ( sigaction(signo, &act, &oact) < 0 ) {
            return SIG_ERR;
        }
        return oact.sa_handler;
    } 
    
    
    void str_echo( int cfd ) {
        ssize_t n;
        char buf[1024];
    again:
        memset(buf, 0, sizeof(buf));
        while( (n = read(cfd, buf, 1024)) > 0 ) {
            write(cfd, buf, n); 
        }
        if( n <0 && errno == EINTR ) {
            goto again; 
        } else {
            printf("str_echo: read error\n");
        }
    }
    
    int main() {
    
        signal(SIGCHLD, &func_waitpid);    
    
        int s, c;
        pid_t child;
        if( (s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
            int e = errno; 
            perror("create socket fail.\n");
            exit(0);
        }
    
        struct sockaddr_in server_addr, child_addr; 
        bzero(&server_addr, sizeof(server_addr));
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(9998);
        server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
        if( bind(s, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0 ) {
            int e = errno; 
            perror("bind address fail.\n");
            exit(0);
        }
    
        if( listen(s, 1024) < 0 ) {
            int e = errno; 
            perror("listen fail.\n");
            exit(0);
        }
        while(1) {
            socklen_t chilen = sizeof(child_addr); 
            if ( (c = accept(s, (struct sockaddr *)&child_addr, &chilen)) < 0 ) {
                perror("listen fail.");
                exit(0);
            }
    
            if( (child = fork()) == 0 ) {
                close(s); 
                str_echo(c);
                exit(0);
            }
            close(c);
        }
    }
    
    //client.c
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/socket.h>
    #include <errno.h>
    #include <error.h>
    #include <netinet/in.h>
    #include <netinet/ip.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <signal.h>
    
    void str_cli(FILE *fp, int sfd ) {
        char sendline[1024], recvline[2014];
        memset(recvline, 0, sizeof(sendline));
        memset(sendline, 0, sizeof(recvline));
        while( fgets(sendline, 1024, fp) != NULL ) {
            write(sfd, sendline, strlen(sendline)); 
            if( read(sfd, recvline, 1024) == 0 ) {
                printf("server term prematurely.\n"); 
            }
            fputs(recvline, stdout);
            memset(recvline, 0, sizeof(sendline));
            memset(sendline, 0, sizeof(recvline));
        }
    }
    
    int main() {
        int s[5]; 
        for (int i=0; i<5; i++) {
            if( (s[i] = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
                int e = errno; 
                perror("create socket fail.\n");
                exit(0);
            }
        }
    
        for (int i=0; i<5; i++) {
            struct sockaddr_in server_addr, child_addr; 
            bzero(&server_addr, sizeof(server_addr));
            server_addr.sin_family = AF_INET;
            server_addr.sin_port = htons(9998);
            inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
            if( connect(s[i], (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0 ) {
                perror("connect fail."); 
                exit(0);
            }
        }
    
        sleep(10);
        str_cli(stdin, s[0]);
        exit(0);
    }

[参考这里][Link 2]

# 守护进程 #

守护进程（deamon）是一类在后台运行的特殊进程，用于执行特定的系统任务。很多守护进程在系统引导的时候启动，并且一直运行直到系统关闭。另一些只在需要的时候才启动，完成任务后就自动结束。例如memcached服务器端或者redis服务器端都可以通过命令行参数设定称为守护进程。下图种用\[\]括起来的进程就是守护进程并且其TTY中端都是？表示没有终端交互，例如kthreadd、init进程。  
![这里写图片描述][70 1]

## daemonize ##

下面分析memcached的守护进程模块，分析如何编写守护进程。这个具体如何编写，咱们先暂时放放，因为暂时不会使用到的。  
编写守护进程的步骤：

*  在父进程中执行fork并exit退出；
 *  在子进程中调用setsid函数创建新的会话；
 *  在子进程中调用chdir函数，让根目录 ”/” 成为子进程的工作目录；
 *  在子进程中调用umask函数，设置进程的umask为0；
 *  在子进程中关闭任何不需要的文件描述符。

int daemonize(int nochdir, int noclose)
    {
        int fd;
    /* 调用fork产生一个子进程，同时父进程退出。我们所有后续工作都在子进程中完成。 这样做的目的在于： 1、如果我们是从命令行执行的该程序，这可以造成程序执行完毕的假象，shell会正常返回。 2、虽然子进程继承了父进程的进程组ID，但获得了一个新的进程ID，这就保证了子进程不是一个进程组的组长进程。 保证setsid执行可成功产生新的会话。 因为组长进程ID等于其进程ID。 3、由于父进程已经先于子进程退出，会造成子进程 变成一个孤儿进程（orphan），并被Init 1号进程收养了。 */
    
        switch (fork()) {
        case -1:
            return (-1);//出错直接返回
        case 0:
            break;//子进程继续向下执行
        default:
            _exit(EXIT_SUCCESS);//父进程则直接退出
        }
    /* 调用setsid系统调用。这是整个过程中最重要的一步。 创建一个新的会话（session），并任此进程为该会话的组长（session leader） 如果调用进程是一个进程组的组长，调用就会失败，但这已经在第1步得到了保证。 调用setsid有3个作用：让进程摆脱原进程的控制。 让进程摆脱原会话的控制； 让进程摆脱原进程组的控制； 让进程摆脱原控制终端的控制； 就是让进程完全独立出来，脱离所有其他进程的控制。 */
        if (setsid() == -1)//设置一个新的会话，成为首进程、成为组长进程、没有控制终端。
            return (-1);
    
    /* 把当前工作目录切换到根目录。因为从父进程处继承过来的当前工作目录可能在一个挂载的 文件系统中。因为守护进程通常在系统在引导之前是一直存在的，所以如果守护进程的当前工作 目录在一个挂载文件系统中，那么该文件系统就不能被卸载。 */
    
        if (nochdir == 0) {
            if(chdir("/") != 0) {
                perror("chdir");
                return (-1);
            }
        }
    
    /* 设置文件权限掩码。将其设置为0，表示不屏蔽任何权限，用户可以进行任何操作。 因为每个进程都会从父进程那里继承 一个文件权限掩码，当创建新文件时，这个掩码被用于设定文件的默认访问权限， 屏蔽掉某些权限，如一般用户的写权限。当另一个进程用exec调用我们编写的daemon程序时，由于我们不知道那个进程 的文件权限掩码是什么，这样在我们创建新文件时，就会带来一些麻烦。所以，我们应该重新设置文 件权限掩码，我们可以设成任何我们想要的值，但一般情况下，大家都把它设为0，这样，它就不会 屏蔽用户的任何操作。 如果你的应用程序根本就不涉及创建新文件或是文件访问权限的设定，你也完全可以把文件权限 掩码一脚踢开，跳过这一步。关闭所有不需要的文件。同文件权限掩码一样，我们的新进程会从父 进程那里继承一些已经打开了的文件。这些被打开的文件可能永远不被我们的daemon进程读或写， 但它们一样消耗系统资源，而且可能导致所在的文件系统无法卸下。需要指出的是，文件描述符为0、1和2 的三个文件，也就是我们常说的输入、输出和报错这三个文件也需要被关闭。 很可能不少读者会对此感到奇怪，难道我们不需要输入输出吗？但事实是，在上面的第2步 后，我们的daemon进程已经与所属的控制终端失去了联系，我们从终端输入的字符不可能达到daemon进程， daemon进程用常规的方法（如printf）输出的字符也不可能在我们的终端上显示出来。所以这三个文件已经 失去了存在的价值，也应该被关闭。 */
        // 设置文件权限掩码 
        // umask(0) ; // 这里原本没有，只是为了上面的基本流程说明加上的 
    
    
        ///dev/null 是 Unix/Linux 里的无底洞设备
        if (noclose == 0 && (fd = open("/dev/null", O_RDWR, 0)) != -1) {
            if(dup2(fd, STDIN_FILENO) < 0) {
       //将标准输入重定向到fd。
                perror("dup2 stdin");
                return (-1);
            }
            if(dup2(fd, STDOUT_FILENO) < 0) {
       //将标准输出重定向到fd。
                perror("dup2 stdout");
                return (-1);
            }
            if(dup2(fd, STDERR_FILENO) < 0) {
       //将标准错误重定向到fd。
                perror("dup2 stderr");
                return (-1);
            }
    
            if (fd > STDERR_FILENO) {
       //并关闭fd，节约资源。
                if(close(fd) < 0) {
                    perror("close");
                    return (-1);
                }
            }
        }
        return (0);
    }

[Link 1]: http://blog.csdn.net/u010710458/article/details/79617395
[ps]: https://blog.csdn.net/u010710458/article/details/78452067#t32
[70]: /images/20220529/d46eb3fe3c9640eeac0696ca13ff455c.png
[Image 1]: 
[Link 2]: https://www.cnblogs.com/yuxingfirst/p/3165407.html
[70 1]: /images/20220529/a7077a00f8df49539ddcd00ce604714b.png