進程詳解（1）——可能是最深入淺出的進程學習筆記

原文地址：http://www.cnblogs.com/jacklu/p/5317406.html

 

進程控制塊（PCB）

在Linux中task_struct結構體即是PCB。PCB是進程的唯一標識，PCB由鏈表實現（為了動態插入和刪除）。

進程創建時，為該進程生成一個PCB；進程終止時，回收PCB。

PCB包含信息：1、進程狀態（state）；2、進程標識信息（uid、gid）；3、定時器（time）；4、用戶可見寄存器、控制狀態寄存器、棧指針等（tss）

 

每個進程都有一個 非負的 唯一進程ID（PID）。雖然是唯一的，但是PID可以重用，當一個進程終止后，其他進程就可以使用它的PID了。

PID為0的進程為調度進程，該進程是內核的一部分，也稱為系統進程；PID為1的進程為init進程，它是一個普通的用戶進程，但是以超級用戶特權運行；PID為2的進程是頁守護進程，負責支持虛擬存儲系統的分頁操作。

除了PID，每個進程還有一些其他的標識符：

 

五種進程狀態轉換如下圖所示：

 

 

每個進程的task_struct和系統空間堆棧存放位置如下：兩個連續的物理頁【《Linux內核源代碼情景分析》271頁】

系統堆棧空間不能動態擴展，在設計內核、驅動程序時要避免函數嵌套太深，同時不宜使用太大太多的局部變量，因為局部變量都是存在堆棧中的。

 

進程的創建

新進程的創建，首先在內存中為新進程創建一個task_struct結構，然后將父進程的task_struct內容復制其中，再修改部分數據。分配新的內核堆棧、新的PID、再將task_struct 這個node添加到鏈表中。所謂創建，實際上是“復制”。

 

子進程剛開始，內核並沒有為它分配物理內存，而是以只讀的方式共享父進程內存，只有當子進程寫時，才復制。即“copy-on-write”。

fork都是由do_fork實現的，do_fork的簡化流程如下圖：

fork函數

fork函數時調用一次，返回兩次。在父進程和子進程中各調用一次。 子進程中返回值為0，父進程中返回值為子進程的PID。程序員可以根據返回值的不同讓父進程和子進程執行不同的代碼。

一個形象的過程：

運行這樣一段演示程序：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
 pid_t pid;
 char *message;
 int n = 0;
 pid = fork();
 while(1){
 if(pid < 0){
 perror("fork failed\n");
 exit(1);
 }
 else if(pid == 0){
 n--;
 printf("child's n is:%d\n",n);
 }
 else{
 n++;
 printf("parent's n is:%d\n",n);
 }
 sleep(1);
 }
 exit(0);
}

 

運行結果：

可以發現子進程和父進程之間並沒有對各自的變量產生影響。

一般來說，fork之后父、子進程執行順序是不確定的，這取決於內核調度算法。進程之間實現同步需要進行進程通信。

什么時候使用fork呢？

一個父進程希望子進程同時執行不同的代碼段，這在網絡服務器中常見——父進程等待客戶端的服務請求，當請求到達時，父進程調用fork，使子進程處理此請求。

一個進程要執行一個不同的程序，一般fork之后立即調用exec

vfork函數

vfork與fork對比：

相同：

返回值相同

不同：

fork創建子進程，把父進程數據空間、堆和棧 復制一份；vfork創建子進程，與父進程內存數據 共享；

vfork先保證子進程先執行，當子進程調用exit()或者exec后，父進程才往下執行

為什么需要vfork？

因為用vfork時，一般都是緊接着調用exec，所以不會訪問父進程數據空間，也就不需要在把數據復制上花費時間了，因此vfork就是”為了exec而生“的。

 

運行這樣一段演示程序：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
 pid_t pid;
 char *message;
 int n = 0;
 int i;
 pid = vfork();
 for(i = 0; i < 10; i++){
 if(pid < 0){
 perror("fork failed\n");
 exit(1);
 }
 else if(pid == 0){
 n--;
 printf("child's n is:%d\n",n);
 if(i == 1)
 _exit(0);
 //return 0;
 //exit(0);
 }
 else{
 n++;
 printf("parent's n is:%d\n",n);
 }
 sleep(1);
 }
 exit(0);
}

 

運行結果：

可以發現子進程先被執行，exit后，父進程才被執行，同時子進程改變了父進程中的數據

子進程return 0 會發生什么？

 

運行結果：

從上面我們知道，結束子進程的調用是exit()而不是return，如果你在vfork中return了，那么，這就意味main()函數return了，注意因為函數棧父子進程共享，所以整個程序的棧就跪了。 如果你在子進程中return，那么基本是下面的過程： 1）子進程的main() 函數 return了，於是程序的函數棧發生了變化。 2）而main()函數return后，通常會調用 exit()或相似的函數（如：_exit()，exitgroup()） 3）這時，父進程收到子進程exit()，開始從vfork返回，但是尼瑪，老子的棧都被你子進程給return干廢掉了，你讓我怎么執行？（注：棧會返回一個詭異一個棧地址，對於某些內核版本的實現，直接報“棧錯誤”就給跪了，然而，對於某些內核版本的實現，於是有可能會再次調用main()，於是進入了一個無限循環的結果，直到vfork 調用返回 error） 好了，現在再回到 return 和 exit，return會釋放局部變量，並彈棧，回到上級函數執行。exit直接退掉。如果你用c++ 你就知道，return會調用局部對象的析構函數，exit不會。（注：exit不是系統調用，是glibc對系統調用 _exit()或_exitgroup()的封裝） 可見，子進程調用exit() 沒有修改函數棧，所以，父進程得以順利執行

【《vfork掛掉的一個問題》 http://coolshell.cn/articles/12103.html#more-12103】

execve

可執行文件裝入內核的linux_binprm結構體。

進程調用exec時，該進程執行的程序完全被替換，新的程序從main函數開始執行。因為調用exec並不創建新進程，只是替換了當前進程的代碼區、數據區、堆和棧。

六種不同的exec函數：

當指定filename作為參數時：

如果filename中包含/，則將其視為路徑名。

否則，就按系統的PATH環境變量，在它所指定的各個目錄中搜索可執行文件。

 

*出於安全方面的考慮，有些人要求在搜索路徑中不要包括當前目錄。

在這6個函數中，只有execve是內核的系統調用。另外5個只是庫函數，他們最終都要調用該系統調用，如下圖所示：

execve的實現由do_execve完成，簡化的實現過程如下圖：

 

關於這些函數的區別，需要時可以查看《APUE》關於exec函數部分的內容。

 

運行這樣一段演示程序：

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

char command[256];
void main()
{
   int rtn; /*child process return value*/
   while(1) {
       printf( ">" );
       fgets( command, 256, stdin );
       command[strlen(command)-1] = 0;
       if ( fork() == 0 ) {
          execlp( command, NULL );
          perror( command );
          exit( errno );
       }
           else {
          wait ( &rtn );
          printf( " child process return %d\n", rtn );
       }
   }
}

 

a.out 是一個打印hello world的可執行文件。

運行結果：

進程終止

正常終止（5種）

從main返回，等效於調用exit

調用exit

exit 首先調用各終止處理程序，然后按需多次調用fclose，關閉所有的打開流。

調用_exit或者_Exit

最后一個線程從其啟動例程返回

最后一線程調用pthread_exit

異常終止（3種）

調用abort

接到一個信號並終止

最后一個線程對取消請求作出響應

 

wait和waitpid函數

wait用於使父進程阻塞，等待子進程退出；waitpid有若干選項，如可以提供一個非阻塞版本的wait，也能實現和wait相同的功能，實際上，linux中wait的實現也是通過調用waitpid實現的。

waitpid返回值：正常返回子進程號；使用WNOHANG且沒有子進程退出返回0；調用出錯返回-1；

運行如下演示程序

 

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h> 

int main()
{
        pid_t pid0,pid1;
        pid0 = fork();
        if(pid0 < 0){
                perror("fork");
                exit(1);
        }
        else if(pid0 == 0){
                sleep(5);
                exit(0);//child
        }
        else{
                do{
                        pid1 = waitpid(pid0,NULL,WNOHANG);
                        if(pid1 == 0){
                                printf("the child process has not exited.\n");
                                sleep(1);
                        }
                }while(pid1 == 0);
                if(pid1 == pid0){
                        printf("get child pid:%d",pid1);
                        exit(0);
                }
                else{
                        exit(1);
                }
        }
        return 0;
}



當把第三個參數WNOHANG改為0時，就不會有上面五個顯示語句了，說明父進程阻塞了。



a.out 的代碼如下：


#include <stdio.h>
void main()

{
        printf("hello WYJ\n");
}

 

process.c的代碼如下：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/times.h>
#include <sys/wait.h>

int main()
{
        pid_t pid_1,pid_2,pid_wait;
        pid_1 = fork();
        pid_2 = fork();
        if(pid_1 < 0){
                perror("fork1 failed\n");
                exit(1);
        }else if(pid_1 == 0 && pid_2 != 0){//do not allow child 2 to excute this process.
                if(execlp("./a.out", NULL) < 0){
                        perror("exec failed\n");
                }//child;       
                exit(0);
        }
        if(pid_2 < 0){
                perror("fork2 failded\n");
                exit(1);
        }else if(pid_2 == 0){
                sleep(10);
        }
        if(pid_2 > 0){//parent 
                do{
                        pid_wait = waitpid(pid_2, NULL, WNOHANG);//no hang
                        sleep(2);
                        printf("child 2 has not exited\n");
                }while(pid_wait == 0);
                if(pid_wait == pid_2){
                        printf("child 2 has exited\n");
                        exit(0);
                }else{
                //      printf("pid_2:%d\n",pid_2);
                        perror("waitpid error\n");
                        exit(1);

               }
        }
        exit(0);
}

 

運行結果：

 

編寫一個多進程程序：該實驗有 3 個進程，其中一個為父進程，其余兩個是該父進程創建的子進程，其中一個子進程運行“ls -l”指令，另一個子進程在暫停 5s 之后異常退出，父進程並不阻塞自己，並等待子進程的退出信息，待收集到該信息，父進程就返回。

#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
 pid_t child1,child2,child;
 if((child1 = fork()) < 0){
 perror("failed in fork 1");
 exit(1);
 }
 if((child2 = fork()) < 0){
 perror("failed in fork 2");
 exit(1);
 }
 if(child1 == 0){
 //run ls -l
 if(child2 == 0){
 printf("in grandson\n");
 }
 else if(execlp("ls", "ls", "-l", NULL) < 0){
 perror("child1 execlp");
 }
 }
 else if(child2 == 0){
 sleep(5);
 exit(0);
 }
 else{
 do{
 sleep(1);
 printf("child2 not exits\n");
 child = waitpid(child2, NULL, WNOHANG);
 }while(child == 0);
 if(child == child2){
 printf("get child2\n");
 }
 else{
 printf("Error occured\n");
 }
 }
}

 

運行結果：

init進程成為所有僵屍進程（孤兒進程）的父進程

僵屍進程

在進程調用了exit之后，該進程並非馬上就消失掉，而是留下了一個成為僵屍進程的數據結構，記載該進程的退出狀態等信息供其他進程收集，除此之外，僵屍進程不再占有任何內存空間。

子進程結束之后為什么會進入僵屍狀態？ 因為父進程可能會取得子進程的退出狀態信息。

如何查看僵屍進程？

linux中命令ps，標記為Z的進程就是僵屍進程。

執行下面一段程序：

 

#include <sys/types.h>
#include <unistd.h>
int main()
{
 pid_t pid;
 pid = fork();
 if(pid < 0){
 printf("error occurred\n");
 }else if(pid == 0){
 exit(0);
 }else{
 sleep(60);
 wait(NULL);
 }
}

運行結果：

  

ps -ef|grep defunc可以找出僵屍進程

ps -l 可以得到更詳細的進程信息

運行結果顯示：

運行兩次之后發現有兩個Z進程，然后等待一分鍾后，Z進程被父進程回收。

其中S表示狀態：

O：進程正在處理器運行

S：休眠狀態

R：等待運行

I：空閑狀態

Z：僵屍狀態

T：跟蹤狀態

B：進程正在等待更多的內存分頁

C：cpu利用率的估算值

收集僵屍進程的信息，並終結這些僵屍進程，需要我們在父進程中使用waitpid和wait，這兩個函數能夠手機僵屍進程留下的信息並使進程徹底消失。

守護進程Daemon

是linux的后台服務進程。它是一個生存周期較長的進程，沒有控制終端，輸出無處顯示。用戶層守護進程的父進程是init進程。

守護進程創建步驟：

1、創建子進程，父進程退出，子進程被init自動收養；fork    exit

2、調用setsid創建新會話，成為新會話的首進程，成為新進程組的組長進程，擺脫父進程繼承過來的會話、進程組等；setsid

3、改變當前目錄為根目錄，保證工作的文件目錄不被刪除；chdir（“/”）

4、重設文件權限掩碼，給子進程更大的權限；umask（0）

5、關閉不用的文件描述符，因為會消耗資源；close

 

一個守護進程的實例：每隔10s寫入一個“tick”

#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/types.h>
#define MAXFILE 65535

int main()
{
 int fd,len,i;
 pid_t pid;
 char *buf = "tick\n";
 len = strlen(buf);
 if((pid = fork()) < 0){
 perror("fork failed");
 exit(1);
 }
 else if(pid > 0){
 exit(0);
 }
 setsid();
 if(chdir("/") < 0){
 perror("chdir failed");
 exit(1);
 }
 umask(0);
 for(i = 0; i < MAXFILE; i++){
 close(i);
 }
 while(1){
 if((fd = open("/tmp/dameon.log", O_CREAT | O_WRONLY | O_APPEND, 0600)) < 0){
 perror("open log failed");
 exit(1);
 }
 write(fd, buf, len+1);
 close(fd);
 sleep(10);
 }
}

運行結果：

 

 

#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/types.h>
#include<syslog.h>
#define MAXFILE 65535
 
int main()
{
 int fd,len,i;
 pid_t pid,child;
 char *buf = "tick\n";
 len = strlen(buf);
 if((pid = fork()) < 0){
 perror("fork failed");
 exit(1);
 }
 else if(pid > 0){
 exit(0);
 }
 openlog("Jack", LOG_PID, LOG_DAEMON);
 if(setsid() < 0){
 syslog(LOG_ERR, "%s\n", "setsid");
 exit(1);
 }

 if(chdir("/") < 0){
 syslog(LOG_ERR, "%s\n", "chdir");
 exit(1);
 }
 umask(0);
 for(i = 0; i < MAXFILE; i++){
 close(i);
 }
 if((child = fork()) < 0){
 syslog(LOG_ERR, "%s\n", "fork");
 exit(1);
 }
 if(child == 0){
 //printf("in child\n");//can not use terminal from now on.
 syslog(LOG_INFO, "in child");
 sleep(10);
 exit(0);
 }
 else{
 waitpid(child, NULL, 0);
 //printf("child exits\n");//can not use terminal from now on.
 syslog(LOG_INFO, "child exits");
 closelog();
 while(1){
 sleep(10);
 }
 }

}

 

真正編寫調試的時候會發現需要殺死守護進程。

如何殺死守護進程？

ps -aux  找到對應PID

kill -9 PID

 

  

其他參考資料：

《APUE》

《操作系統》清華大學公開課 向勇、陳渝

《嵌入式Linux應用程序開發詳解》

《LInux 的僵屍（zombie）進程》 http://coolshell.cn/articles/656.html

《Linux下僵屍進程的處理》 http://www.mike.org.cn/articles/treatment-of-zombie-processes-under-linux/