Linux 進程編程入門

關於進程和線程的關係,之前一口君寫過這幾篇文章,大家可以參考下。

本文從頭帶着大家一起學習Linux進程

搞懂進程組、會話、控制終端關係,才能明白守護進程幹嘛的?

[粉絲問答6]子進程進程的父進程關係

多線程詳解,一篇文章徹底搞懂多線程中各個難點

一個多線程的簡單例子讓你看清線程調度的隨機性

Linux 進程篇

一、進程相關概念

瞭解進程的時候先來了解幾個問題,明白以下問題,就懂了進程的概念

1.什麼是程序,什麼是進程,兩者之間的區別?

  1. 程序是靜態的概念,gcc  xxx.c -o pro 磁盤中生成pro文件,叫做程序              程序如:電腦上的圖標
  2. 進程是程序的一次運行活動, 通俗點說就是程序跑起來了,系統中就多了一個進程

2.如何查看系統中有哪些進程?

  1. 使用ps指令查看     :  ps-aux  在ubuntu下查看, 在實際工作中,配合grep來查找程序中是否存在某一個進程

    grep  過濾進程   :ps -aux | grep init 就只把帶有init的進程過濾出來圖片

  2. 使用top指令查看,類似windows任務管理器

3.什麼是進程標識符?

每一個進程都有一個非負整數表示的唯一ID,叫做pid,類似身份證

pid =0 :稱爲交換進程(swapper)作用:進程調度pid=1  :init 進程作用:系統初始化

  • 編程調用getpid函數獲取自身的進程標識符;
#include<sys/types.h>
#include<unistd.h>
pid_t getpid(void);
pid_t getppid(void);

getpid示例代碼:

#include<stidio.h>
#include<sys/types.h>
#include<unistd.h>

int main()
{
    pid_t pid;
    pid = getpid();
   printf("my pid is %d\n",pid);
   return 0;
}
  • getppid獲取父進程的進程標識符;

4. 第一個進程  init 進程

圖片在這裏插入圖片描述

Linux內核啓動之後,會創建第一個用戶級進程init,由上圖可知, init 進程 (pid=1) 是除了 idle 進程(pid=0,也就是 init_task) 之外另一個比較特殊的進程,它是 Linux 內核開始建立起進程概念時第一個通過 kernel_thread 產生的進程,其開始在內核態執行,然後通過一個系統調用,開始執行用戶空間的 / sbin/init 程序。

5.什麼叫父進程,什麼叫子進程?

進程A創建了進程B,那麼A叫做父進程,B叫做子進程,父進程是相對的概念,理解爲人類中的父子關係

6. c程序的存儲空間是如何分配的?

gcc xxx.c  -o a.out    當執行 ./a.out 時候,操作系統會劃分一塊內存空間,如何分配呢?如下圖:圖片

二、創建進程函數fork的使用

==pid_t fork(void);== 功能:使用fork函數創建一個進程

fork函數調用成功,返回兩次 返回值爲0  ,代表當前進程是子進程 返回值非負數,代表當前進程爲父進程 調用失敗 ,返回-1

1. fork();示例代碼

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>

int main()
{
    pid_t pid;
    pid = getpid();
    
    fork();
    
   printf("my pid is %d\n",pid);
   return 0;
}

打印出了兩遍 my pid  說明,有了兩個進程!執行了兩次打印pid圖片

2. 查看父進程/子進程代碼:

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>

int main()
{
    pid_t pid;
    pid_t pid2;

    pid = getpid();
    printf("brfore fork pid is %d\n",pid);

    fork();

    pid2 = getpid();
    printf("brfore fork pid is %d\n",pid2);

    if(pid == pid2){
         printf("this is father print\n");
    }else{

         printf("this is child print , child pid is =%d\n",getpid());
    }

   return 0;

}

圖片父子進程都會進入if 中,但是輸出結果會不同 在fork之前的pid 是8915 是父進程   ,fork之後pid是子進程 8916

3. 用返回值來判斷父/子進程代碼(1):

返回值爲0  ,代表當前進程是子進程 返回值非負數,代表當前進程爲父進程

#include<sys/types.h>
#include<stdio.h>
#include<unistd.h>

int main()
{

   pid_t pid;

   printf("father: id=%d\n",getpid());

   pid = fork();

   if(pid > 0){
         printf("this is father print ,pid =%d\n",getpid());
   }else if (pid == 0){
         printf("this is child print, child pid = %d\n",getpid());
   }

   return 0;
}

圖片在這裏插入圖片描述

4. 用返回值來判斷父子進程代碼(2):

#include<sys/types.h>
#include<stdio.h>
#include<unistd.h>


int main()
{

   pid_t pid;
   pid_t pid2;
   pid_t retpid;

   pid = getpid();
   printf("before fork: pid = %d\n",pid);


   retpid = fork();


   pid2 = getpid();
   printf("after fork:pid = %d\n",pid2);


   if(pid == pid2){
       printf("this is father print :retpid = %d\n",retpid);
   }else{
       printf("this is child print :retpid =%d,child pid= %d\n",retpid,pid2);
   }

   return 0;
}

圖片這樣更清楚明瞭的看到
fork 返回值:9915>0  是父進程    父進程號是9114 fork 返回值:=0     是子進程         子進程號是9915

三、進程創建後 發生了什麼事?

圖片在這裏插入圖片描述

1 在內存空間中fork後發生了什麼?

圖片在這裏插入圖片描述

2. ./demo4 運行的程序父進程是誰?

int main(int argc, const char *argv[])
{
        while(1);
        return 0;
}

./ demo4 編譯運行後,我們ps -ef 查看進程ID圖片由上圖可知,./demo4 進程的進程ID是12677,父進程ID是12587,即進程bash:==bash的父進程是gnome-terminal,所以我們打開1個Linux終端,其實就是啓動了1個gnome-terminal進程。我們在這個終端上執行./a.out其實就是利用gnome-terminal的子進程bash通過execve()將創建的子進程裝入a.out:==

四、創建新進程的實際應用場景

1. fork創建子進程的一般目的:

  • 一個父進程希望複製自己,使父、子進程同時執行不同的代碼段。這在網絡服務進程中是常見的——父進程等待客戶端的服務請求。當這種情求達到時,父進程調用fork,使子進程處理此請求。父進程則繼續等待下一個服務請求到達。

  • 一個進程要執行一個不同的程序。這對shell是常見的情況,在這種情況下子進程從fork返回後立即調用exec。

圖片在這裏插入圖片描述

2. 模擬socket 創建進程(服務器對接客戶端的應用場景)示例代碼:

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>

int main()
{
   pid_t  pid;
   int data;

   while(1){
        printf("please input a data\n");
        scanf("%d",&data);

        if(data ==1 )
        {
            pid = fork();

            if(pid >0){

            }
            else if(pid == 0){
                  while(1){
                        printf("do net request,pid=%d\n",getpid());
                        sleep(3);
                  }
            }
        }
        else{
           printf("wait, do noting\n");
        }
   }
   return 0;
}

輸入非1時候,模擬沒有客戶端進行交互圖片輸入1時候,模擬有客戶端進行交互 ,創建子進程來進行交互,子進程號爲:9756圖片模擬多個客戶端進行交互時 ,創建多個子進程來進行交互,子進程號爲:9756   / 9758  / 9759圖片查看系統進程:圖片

3. fork總結:

一個現有進程可以調用fork函數創建一個新進程。

#include cunistd.h> pid_t fork(void); 返回值:子進程中返回0。父進程中返回子進程ID.出錯返回-1

由fork創建的新進程被稱爲子進程(child process)。fork函數被調用一次,但返回兩次。兩次返回的唯一區別是子進程的返回值是0,而父進程的返回值則是新子進程的進程ID。將子進程ID返回給父進程的理由是:因爲一個進程的子進程可以有多個,並且沒有一個函數使一個進程可以獲得其所有子進程的進程ID。fork使子進程得到返回值0的理由是:一個進程只會有一個父進程,所以子進程總是可以調用getppid以獲得其父進程的進程ID(進程ID0總是由內核交換進程使用,所以一個子進程的進程ID不可能爲0)。

子進程和父進程繼續執行fork調用之後的指令。子進程是父進程的副本。例如,子進程獲得父進程數據空間、堆和棧的副本。注意,這是子進程所擁有的副本。父、子進程並不共享這些存儲空間部分。父、子進程共享正文段。由於在fork之後經常跟隨着exec,所以現在的很多實現並不執行一個父進程數據段、棧和堆的完全複製。作爲替代,使用了寫時複製(Copy-On-Write,COW)技術。這些區域由父、子進程共享,而且內核將它們的訪問權限改變爲只讀的。如果父、子進程中的任一個試圖修改些區域,則內核只爲修改區域的那塊內存製作一個副本,通常是虛擬存儲器系統中的一“頁”。Bach和McKusick等對這種特徵做了更詳細的說明。

五、vfork創建進程

1. vfork函數 也可以創建進程,與fork有什麼區別?

關鍵區別一:vfork直接使用父進程存儲空間,不用拷貝關鍵區別二:vfork保證子進程先運行,當子進程調用exit退出後,父進程才執行

2. fork 進程調度 父子進程:

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>

int main()
{
    pid_t pid;

    pid = fork();

    if(pid >0){
       while(1){
               printf("this is father print pid is %d\n",getpid());
               sleep(3);
       }
    }else if(pid == 0){
         while(1){
               printf("this is child print pid is =%d\n",getpid());
               sleep(3);
         }
    }

   return 0;

}

圖片在這裏插入圖片描述

3.  vfork 進程調度 父子進程:

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

int main()
{
    pid_t pid;
    int cnt=0;

    pid = vfork();

    if(pid >0){
       while(1){
               printf("this is father print pid is %d\n",getpid());
               sleep(1);
       }
    }else if(pid == 0){
         while(1){
               printf("this is child print pid is =%d\n",getpid());
               sleep(1);
               cnt++;
               if(cnt == 3 ){
                   exit(0);
               }
         }
    }

   return 0;
}

vfork保證子進程先運行,當子進程調用3次   exit退出後,父進程才執行圖片

4. 子進程改變cnt值,在父進程運行時候也被改變

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

int main()
{
    pid_t pid;
    int cnt=0;
    printf("cnt=%d\n",cnt);

    pid = vfork();

    if(pid >0){
       while(1){
               printf("cnt=%d\n",cnt);
               printf("this is father print pid is %d\n",getpid());
               sleep(1);
       }
    }else if(pid == 0){
         while(1){
               printf("this is child print pid is =%d\n",getpid());
               sleep(1);
               cnt++;
               if(cnt == 3 ){
                  exit(0);
               }
         }
    }

   return 0;
}

圖片在這裏插入圖片描述

六、ps 常帶的一些參數

下面對ps命令選項進行說明:

命令參數說明
-e 顯示所有進程.
-f 全格式。
-h 不顯示標題。
-l 長格式。
-w 寬輸出。
-a 顯示終端上的所有進程,包括其他用戶的進程。
-r 只顯示正在運行的進程。
-u 以用戶爲主的格式來顯示程序狀況。
-x 顯示所有程序,不以終端機來區分。

ps -ef  顯示所有進程,全格式形式查看進程:

ps -ef 的每列的含義是什麼呢?

圖片在這裏插入圖片描述

命令參數說明
UID: 程序被該 UID 所擁有,指的是用戶ID
PID: 就是這個程序的 ID
PPID : PID的上級父進程的ID
C : CPU使用的資源百分比
STIME : 系統啓動時間
TTY: 登入者的終端機位置
TIME : 使用掉的 CPU時間。
CMD: 所下達的指令爲何

七、進程退出

1. 子進程退出方式

正常退出:

  1. Mian函數調用return
  2. 進程調用exit(),標準c庫
  3. 進程調用_exit()或者——Exit(),屬於系統調用
  4. 進程最後一個線程返回
  5. 最後一個線程調用pthread_exit

異常退出:

  1. 調用abort
  2. 當進程收到某些信號時候,如ctrl+C
  3. 最後一個線程對取消(cancellation),請求作出響應

不管進程如何終止,最後都會執行內核中的同一段代碼。這段代碼爲相應進程關閉所有打開描述符,釋放它所使用的存儲器等。

對上述任意一種終止情形,我們都希望終止進程能夠通知其父進程它是如何終止的。對於三個終止函數(exit、_exit和_Exit),實現這一點的方法是,將其退出狀態作爲參數傳送給函數。【如上面示例裏面寫到的cnt==3情況下,exit(0); 這個0就是子進程退出狀態。】在異常終止情況下,內核(不是進程本身)產生一個指示其異常終止原因的終止狀態。在任何一種情況下,該終止進程的父進程都能用wait或者waitpid取得其終止狀態。

正常退出的三個函數:

#include<stdlib.h>
void exit(int status);


#include<unistd.h>
void _exit(int status);


#include<stdlib.h>
void _Exit(int status);

記得在結束子進程的時候要手動退出,不要使用break;會導致數據被破壞。 三種退出函數種,更推薦exit();  exit是 _exit 和_Exit 的一個封裝, 會清除,沖刷緩衝區,把緩存區數據進程處理在退出。

2. 等待子進程退出

==爲什麼要等待子進程退出?==

創建子進程的目的就是爲了讓它去幹活,在網絡請求當中來了一個新客戶端介入,創建子進程去交互,幹活也要知道它幹完沒有.比如正常退出(exit/_exit /_Exit)爲 完成任務 若異常退出  (abort)不想幹了, 或被殺了

所有要等待子進程退出,而且還要收集它退出的狀態 等待就是調用wait函數 和 waitpid函數

3. 殭屍進程

子進程退出狀態不被收集,會變成僵死進程殭屍進程

正如以下例子,就是子進程退出沒有被收集,成了殭屍進程:

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

int main()
{
    pid_t pid;
    int cnt=0;
    printf("cnt=%d\n",cnt);
    
    pid = vfork();
    
    if(pid >0){
       while(1){
               printf("cnt=%d\n",cnt);
               printf("this is father print pid is %d\n",getpid());
               sleep(1);
       }
    }else if(pid == 0){
         while(1){
               printf("this is child print pid is =%d\n",getpid());
               sleep(1);
               cnt++;
               if(cnt == 3 ){
                  exit(0);
               }
         }
    }
   return 0;
}

圖片運行三次子進程後,退出,父進程一直運行圖片結果:在查看進程時發現,父進程11314正在運行  “S+”   而子進程11315 停止運行 “z+” z表示zombie(殭屍)

4. 等待函數:wait(狀態碼); 的使用:

#include<sys/types.h>
#inlcude<sys/wait.h>

pid_t wait(int *status);    //參數status 是一個地址    
pid_t waitpid(pid_t pid , int *status ,int options);
int waitid(idtype_t idtype ,id_t id ,siginfo_t  *infop, int  options);
  • 如果其所有子進程都還在運行,則阻塞。:通俗的說就是子進程在運行的時候,父進程卡在wait位置阻塞,等子進程退出後,父進程開始運行。

  • 如果一個子進程已終止,正等待父進程獲取其終止狀態,則會取得該子進程的終止狀態立即返回。

  • 如果它沒有任何子進程,則立即出錯返回。

status參數:是一個整型數指針 非空:子進程退出狀態放在它所指向的地址中。空:不關心退出狀態

檢查wait 和 waitpid 所返回的終止狀態的宏

說明
WIFEXITED (status) 若爲正常終止子進程返回的狀態,則爲真。對於這種情況可執行WEXITSTATUS(status),取子進程傳送給exit、_exit 或_Exit參數的低8位
WIFSIGNALED (status) 若爲異常終止子進程返回的狀態,則爲真(接到一個不捕捉的信號)。對於這種情況,可執行WTERMSIG(status),取使子進程終止的信號編號。另外,有些實現(非Single UNIX Specification)宏義宏WCOREDUMP(status),若已產生終止進程的core文件,則它返回真
WIFSTOPPED (status) 若爲當前暫停子進程的返回的狀態,則爲真,對於這種情況,可執行WSTIOPSIG(status),取使子進程暫停的信號編號
WIFCONTINUED (status) 若在作業控制暫停後已經繼續的子進程返回了狀態,則爲真。(POSIX.1的XSI擴展,僅用於waitpid。)
比如說:exit(3)  wait (狀態碼); 要通過宏來解析狀態碼  

5. 收集退出進程狀態

pid = vfork();

    if(pid >0){
       while(1){
               printf("cnt=%d\n",cnt);
               printf("this is father print pid is %d\n",getpid());
               sleep(1);
       }
    }else if(pid == 0){
         wait(NULL);    // 參數:status  是一個地址  爲空 表示不關心退出狀態
         while(1){
               printf("this is child print pid is =%d\n",getpid());
               sleep(1);
               cnt++;
               if(cnt == 3 ){
                  exit(0);
               }
         }
    }

wait(NULL);    // 參數:status  是一個地址  爲空 表示不關心退出狀態

沒有了11567子進程,這樣就不是殭屍進程了圖片收集子進程退出狀態示例代碼:

int main()
{
    pid_t pid;
    int cnt=0;
    int status =10;

    printf("cnt=%d\n",cnt);

    pid = vfork();

    if(pid >0){

       wait(&status);     // 參數status是一個地址  
       printf("child out ,chile status =%d\n",WEXITSTATUS(status));  //要解析狀態碼,需要藉助WEXITSTATUS
       while(1){
               printf("cnt=%d\n",cnt);
               printf("this is father print pid is %d\n",getpid());
               sleep(1);
       }
    }else if(pid == 0){
         while(1){
               printf("this is child print pid is =%d\n",getpid());
               sleep(1);
               cnt++;
               if(cnt == 3 ){
                  exit(5);
               } 
          }
   }

int status =10;

wait(&status);     // 參數status是一個地址
printf("child out ,chile status =%d\n",WEXITSTATUS(status));  //要解析狀態碼,需要藉助WEXITSTATUS

圖片結果顯示:exit(5);   就能看到子進程退出的狀態 status=5

6. 等待函數:waitpid()的使用;

wait和waitpid的區別之一:

wait使父進程(調用者)阻塞,waitpid有一個選項 ,可以使父進程(調用者)不阻塞。

pid_t waitpid(pid_t pid , int *status ,int options);

對於waitpid函數種pid參數的作用解釋如下:

  
pid == -1 等待任一子進程。就這一方面而言,waitpid與wait等效。
pid > 0 等待其進程ID與pid相等的子進程。
pid == 0 等待其組ID等於調用進程組ID的任一子進程
pid <-1 等待其組ID等於pid絕對值的任一子進程。

waitpid 的 options 常量:

  
WCONTINUED 若實現支持作業控制,那麼由pid指定的任一子進程在暫停後已經繼續,但其狀態尚未報告,則返回其狀態(POSIX.1的XSI擴展)
WNOHANG 若由pid指定的子進程並不是立即可用的,則waitpid不阻塞,此時其返回值爲0;
WUNTRACED 若某實現支持作業控制,而由pid指定的任一子進程已處於暫停狀態。

waitpid 來使得父進程不阻塞代碼:

int main()
{
    pid_t pid;
    int cnt=0;
    int status =10;
    
    printf("cnt=%d\n",cnt);

    pid = vfork();

    if(pid >0){

       waitpid(pid,&status,WNOHANG); // 參數pid 是子進程號,WNOHANG是若由pid指定的子進程並不是立即可用的,則waitpid不阻塞,此時其返回值爲0;
       printf("child out ,chile status =%d\n",WEXITSTATUS(status));  
       while(1){
               printf("cnt=%d\n",cnt);
               printf("this is father print pid is %d\n",getpid());
               sleep(1);
       }
    }else if(pid == 0){
         while(1){
               printf("this is child print pid is =%d\n",getpid());
               sleep(1);
               cnt++;
               if(cnt == 3 ){
                  exit(5);
               }
          }
   }

圖片子進程和父進程同時進行圖片但是發現子進程12275  在系統查詢進程中  還是變成了殭屍進程原因是 ==WNOHANG是不等待參數,它只運行一遍== ,當他運行時候,子進程沒死,等子進程死後,他沒運行,就沒有收到停止狀態,所以成了殭屍進程。

八、孤兒進程

1. 孤兒進程的概念:

父進程如果不等待子進程退出,在子進程結束前就了結束了自己的“生命”,此時子進程就叫做孤兒進程。

2.孤兒進程被收留:

Linux避免系統存在過多孤兒進程,init進程收留孤兒進程,變成孤兒進程的父進程【init進程(pid=1)是系統初始化進程】。init 進程會自動清理所有它繼承的殭屍進程。

孤兒進程的代碼:

#include<sys/types.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
    pid_t pid;
    int cnt=0;
    int status =10;
    pid = fork();

    if(pid >0){
               printf("this is father print pid is %d\n",getpid());
       }
    else if(pid == 0){
         while(1){
               printf("this is child print pid is =%d,my father pid is=%d\n",getpid(),getppid());
               sleep(1);
               cnt++;
               if(cnt == 3 ){
                  exit(5);
               }
         }
    }
   return 0;
}

圖片父進程運行結束前,子進程的父進程pid還是13098。父進程運行結束後,子進程的父進程變成了init進程( pid=1)。圖片

九、exec族函數

1. exec族函數的作用:

我們用fork函數創建新進程後,經常會在新進程中調用exec函數去執行另外一個程序。當進程調用exec函數時,該進程被完全替換爲新程序因爲調用exec函數並不創建新進程,所以前後進程的ID並沒有改變。

2. 爲什麼要用exec族函數,有什麼作用?

  1. 一個父進程希望複製自己,使父、子進程同時執行不同的代碼段。這在網絡服務進程中是常見的——父進程等待客戶端的服務請求。當這種請求到達時,父進程調用fork,使子進程處理此請求。父進程則繼續等待下一個服務請求到達。
  2. 一個進程要執行一個不同的程序。這對shell是常見的情況。在這種情況下,子進程從fork返回後立即調用exec。

3. exec族函數定義:

功能:

exec函數族提供了一種在進程中啓動另一個程序執行的方法,它可以根據指定的文件名或目錄名找到可執行文件,並用它來取代原調用進程的數據段、代碼段和堆棧段。在執行完之後,原調用進程的內容除了進程號外,其他全部都被替換了。在調用進程內部執行一個可執行文件,可執行文件既可以是二進制文件,也可以是linux下可執行的腳本文件。【通俗理解就是執行demo1的同時,執行一半去執行demo2。】

函數族:

execl、execlp、execle、execv、execvp、execvpe

函數原型:

#include<unistd.h>

extern char **environ;
int execl(char *path  , char *arg ,  ...);
int execlp(char *file  , char *arg ,  ...);
int execle(char *path  , char *arg ,  ... , char *const envp[] );
int execv(char *path  , char *const argv[] );
int execvp(char *file  , char *const atgv[] );
int execvpe(char *file  , char *const argv[] , char *const envp[]);

返回值:

exec函數族的函數執行成功後不會返回,調用失敗時,會設置errno並返回-1,然後從原程序的調用點接着往下執行。

參數說明:

path :可執行文件的路徑名字arg:可執行程序所帶的參數,第一個參數爲可執行文件名字,沒有帶路徑且arg必須以NULL結束。file:如果參數file中包含/,則就將其視爲路徑名,否則就按PATH環境變量,在它所指定的各目錄中搜尋可執行文件。

exec族函數參數極難記憶和分辨,函數名中的字符會給我們一些幫助:

字符說明
l 使用參數列表
p 使用文件名,並從PATH環境尋找可執行文件
v 應該先構造一個指向各參數的指針數組,然後將該數組的地址作爲這些函數的參數。
e 多了envp[]數組,使用新的環境變量代替調用進程的環境變量

4. exec函數 帶 l  帶p  帶v  來說明參數特點

先寫一個帶參數的程序,輸入參數 輸出參數,在上一篇Linux文件編程裏,main參數我們學過。

./echoarg代碼:

#include<stdio.h>
int main(int argc , char *argv[])
{

     int i =0;
     for(i =0 ;i <argc;i++){
         printf("argv[%d]:%s\n",i ,argv[i]);
     }
   return 0;
}

在執行a.out 代碼一半的時候,調用上面的代碼echoarg

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

int main(void)
{
     printf("brfore execl\n");
     //int execl(char *path  , char *arg ,  ...);
     if(execl("/bin/echoarg","echoarg","abc",NULL)==-1)
     {
         printf("execl failed!\n");
     }
     printf("after execl \n");
     return 0;
}

exec函數族的函數執行成功後不會返回,調用失敗時,會設置errno並返回-1,然後從原程序的調用點接着往下執行。

if(execl("/bin/echoarg","echoarg","abc",NULL)==-1)源代碼:int execl(char *path  , char *arg ,  ...); //最後一個參數是:arg必須以NULL結束。

在執行a.out 代碼一半的時候,調用上面的代碼echoarg: exec函數族的函數執行成功後不會返回,調用失敗時,會設置errno並返回-1,然後從原程序的調用點接着往下執行。圖片

==perror("why");  //用來在執行錯誤時候,查詢錯誤原因==

若要調用ech 執行一般執行ls ,同理。只需要改動

if(execl("/bin/ls","ls",NULL,NULL)==-1)

圖片若要調用ech 執行一般執行ls-l ,同理。

if(execl("/bin/ls","ls","-l",NULL)==-1)圖片

execlp 和execl 的區別

帶p : 可以通過環境變量PATH環境尋找可執行文件

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

int main(void)
{
     printf("brfore execl\n");
     //int execl(char *path  , char *arg ,  ...);
     if(execl("ls",";s",NULL,NULL)==-1)
     {
         printf("execl failed!\n");
     }
     printf("after execl \n");
     return 0;
}

在路徑中不用寫具體路徑,就可以自動找到文件圖片

execvp 和execl 的區別

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


int main(void)
{
     printf("brfore execl\n");

     char *argv[] = {"ps",NULL,NULL};
     if(execvp("ps",argv)==-1)
     {
         printf("execl failed!\n");
     }
     printf("after execl \n");
     return 0;
}

char *argv[] = {"ps",NULL,NULL}; if(execvp("ps",argv)==-1)

結果與上面相同

5. 任何目錄下執行程序

一個程序在目錄下能運行,換一個目錄就無法運行,如果把程序配置到環境變量裏面去。

==pwd顯示當前路徑 echo

PATH: [pwd顯示的當前路徑]==

 

就可以在任何目錄下執行程序了

6.  exec配合fork使用

一個進程要執行一個不同的程序。這對shell是常見的情況。在這種情況下,子進程從fork返回後立即調用exec。

1. 不用exec的方法: 實現功能,當父進程檢查到輸入爲1的時候,創建子進程把配置文件的字段值修改掉。

#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h> 
#include<string.h> 
#include<stdlib.h> 
#include<unistd.h>

int main()
{
   pid_t pid;
   int data = 10;

   while(1){
         printf("please input a data\n");
         scanf("%d",&data);
         if(data == 1){
                 pid = fork();
                 if(pid>0)
                 { 
                   wait(NULL);
                 }
                 if(pid == 0){
                       int fdSrc;
                       char *readBuf=NULL;
                        fdSrc = open("config.txt",O_RDWR);
                        int size = lseek(fdSrc,0,SEEK_END);
                        lseek (fdSrc,0,SEEK_SET);

                        readBuf =(char *)malloc(sizeof(char)*size+8);
                        int n_read= read(fdSrc,readBuf,size);
                        char *p=strstr(readBuf,"LENG="); //找到(要修改的)位置   
  //參數1 要找的源文件  2.“要找的字符串”
                        if(p==NULL){
                               printf("not found\n");
                               exit(-1);
                         }
                             p=p+strlen("LENG=");  //移動字符串個字節
                               *p='0';      //*p  取內容
lseek (fdSrc,0,SEEK_SET);
                          int n_write =write(fdSrc,readBuf,strlen(readBuf));
                          close(fdSrc);
                          exit(0);
                      }

                    }else {
                                printf("do noting\n");
                          }
           }
                return 0;
}

圖片實現了當父進程檢查到輸入爲1的時候,創建子進程把配置文件的字段值修改掉。圖片2. 用exec的方法: 實現功能,當父進程檢查到輸入爲1的時候,創建子進程把配置文件的字段值修改掉。

int main()
{
   pid_t pid;
   int data = 10;

   while(1){
         printf("please input a data\n");
         scanf("%d",&data);
         if(data == 1){
                 pid = fork();
                 if(pid > 0){
                     wait(NULL);
                 }
                 if(pid == 0){

                   execl("./changdata","changdata","config.txt",NULL);
                   exit(0);
                      }
                    }else {
                                printf("do noting\n");
                          }
           }
                return 0;
}

圖片圖片

使用execl 和 fork  結合 也能做到上面結果,而且更方便,但是在 ./changdata 可執行文件存在的情況下。

十、system函數

1. system函數定義:

函數原型:

 #include<stdlib.h>
int system(const char * string);

函數說明:

system()會調用fork()產生子進程,由子進程來調用/bin/sh-c string來執行參數string字符串所代表的命令,此命令執行完後隨即返回原調用的進程。在調用system()期間SIGCHLD 信號會被暫時擱置,SIGINT和SIGQUIT 信號則會被忽略。

返回值:

system()函數的返回值如下:成功,則返回進程的狀態值;當sh不能執行時,返回127;失敗返回-1;

2. system函數的使用:

用system也可以做到execl的功能用system實現修改配置 數值代碼:

int main()
{
   pid_t pid;
   int data = 10;
   while(1){
         printf("please input a data\n");
         scanf("%d",&data);
         if(data == 1){
                 pid = fork();
                 if(pid > 0){
                     wait(NULL);
                 }
                 if(pid == 0){
                   execl("./changdata config.txt");
                   exit(0);
                      }
                    }else {
                                printf("do noting\n");
                          }
           }
                return 0;
}

圖片在這裏插入圖片描述

3. system和execl不同的是:

sysem運行完調用的可執行文件後還會繼續執行源代碼。

==附加說明:==

在編寫具有SUID/SGID權限的程序時請勿使用system(),system()會繼承環境變量,通過環境變量可能會造成系統安全的問題。

十一、popen函數

1.  popen函數的定義:

函數原型:

#include<stdio.h>
FILE *popen (const char *command ,const char *type); 
int pclose(FILE *stream); 

參數說明:

command: 是一個指向以NULL結束的shell命令字符串的指針。這行命令將被傳到bin/sh並且使用 -c標誌 ,shell將執行這個命令。

type: 只能是讀或者寫中的一種,得到的返回值(標準I/O流)也具有和type相應   的只讀或只寫類型。如果type是”r“ 則文件指針連接到command的標準輸出;如果type是”w“則文件指針連接到command的標準輸入。

返回值:

如果調用成功,則返回一個讀或者打開文件的指針,如果失敗,返回NULL,具體錯誤要根據errno判斷

int pclose(FILE *stream) 參數說明:stream:popen返回對丟文件指針 返回值:如果調用失敗,返回-1

作用:

popen()函數用於創建一個管道:其內部實現爲調用fork產生一個子進程,執行一個shell以運行命令來開啓一個進程這個進程必須由pclose()函數關閉。

popen比system 在應用中的好處:==可以獲取運行的輸出結果==圖片popen函數執行完,執行結果到管道內,數據流出的時候,在管道尾部fread就可以讀出執行數據,就能實現把數據讀到或寫到想要的緩衝區裏。

2. popen函數的使用:

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

int main(void)
{
   char ret[1024]={0};
   FILE *fp;

   fp = popen("ps","r");
   int nread = fread(ret,1,1024,fp);

   printf("read ret %d byte ,ret =%s\n",nread ,ret);
   return 0;
}

結果發現:popen函數結束後,ps 輸出的內容, 都捕獲到 ret 數組裏面去了。popen可以獲取運行的輸出結果 ,可以讀取也可以寫入文件中。圖片

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章