Linux如何啟動新進程

這篇文章將為大家詳細講解有關Linux如何啟動新進程，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

1.system函數-調用shell進程，開啟新進程

system函數，是通過啟動shell進程，然后執行shell命令進程。

原型：

int system(const char *string);

string:shell命令字符串

返回值：成功返回命令退出碼，無法啟動shell，返回127錯誤碼，其他錯誤，返回-1。

代碼示例如下：

process_system.c

#include<stdlib.h>                               
#include<stdio.h>
int main()
{
    printf("Running ps with system\n");
    int code = system("ps au");//新進程結束后，system函數才返回
    //int code = system("ps au");//system函數立即返回
    printf("%d\n",code);
    printf("ps Done\n");
    exit(0);
}

輸出結果：

system函數，在啟動新進程時，必須先啟動shell進程，因此使用system函數的效率不高。

2.exec系列函數-替換進程映像

exec系列函數調用時，啟動新進程，替換掉當前進程。即程序不會再返回到原進程，

除非exec調用失敗。

exec啟動的新進程繼承了原進程的許多特性，如在原進程中打開的文件描述符在新進程中仍保持打開。

需要注意的是，在原進程中打開的文件流在新進程中將關閉。原因在于，我們在前面講過進程間通信的方式，進程之間需要管道才能通信。

原型：

int execl(const char *path,const char *arg0,...,(char*)0);
int execlp(const char *file,const char *arg0,...,(char*)0);
int execle(const char *path,const char *arg0,...,(char*)0,char *const envp[]);
int execv(cosnt char *path,char *const argv[]);
int execvp(cosnt char *file,char *const argv[]);
int execve(cosnt char *path,char *const argv[],char *const envp[]);

path/file：進程命令路徑/進程命令名

argc:命令參數列表

envp:新進程的環境變量

代碼示例如下：

process_exec.c

#include<stdio.h>
int main()
{
  printf("Running ps with execlp\n");
  execlp("ps","ps","au",(char*)0);
  printf("ps done");
  exit(0);
}

輸出結果：

可以看出，調用execlp函數后，原進程被新進程替換，原進程中printf("ps done");沒有被執行到。

3.fork函數-復制進程映像

1)fork函數的使用

fork和exec的替換不同，調用fork函數，可復制一個和父進程一模一樣的子進程。

執行的代碼也完全相同，但子進程有自己的數據空間，環境和文件描述符。

原型：

pid_t fork();

父進程執行時，返回子進程的PID

子進程執行時，返回0

代碼示例如下：

process_fork.c

#include<stdio.h>
#include<sys/types.h>
int main()
{
  pid_t pid = fork();
  switch(pid)
  {
    case -1:
      perror("fork failed");
      exit(1);
      break;
    case 0:
      printf("\n");
      execlp("ps","ps","au",0);
      break;
    default:
      printf("parent,ps done\n");
      break;
  }
  exit(0);
}

輸出結果：

調用fork函數后，新建了一個子進程，拷貝父進程的代碼，數據等到子進程的內存空間。父進程和子進程執行互不影響。使用fork函數的返回值，來區分執行的是父進程，還是子進程。

2)僵尸進程

子進程退出后，內核會將子進程置為僵尸狀態。此時，子進程只保留了最小的一些內核數據結構，如退出碼，以便父進程查詢子進程的退出狀態。這時，子進程就是一個僵尸進程。

在父進程中調用wait或waitpid函數，查詢子進程的退出狀態，可以避免僵尸進程。

原型：

pid_t wait(int *stat_loc);
pid_t waitpid(pid_t pid,int *stat_loc,int options);

stat_loc:若不是空指針，則子進程的狀態碼會被寫入該指針指向的位置。

pid:等待的子進程的進程號pid

options:標記阻塞或非阻塞模式

返回值：成功返回子進程的pid，若子進程沒有結束或意外終止，返回0

wait：阻塞模式(使用了信號量)，父進程調用wait時，會暫停執行，等待子進程的結束。

wait調用返回后，子進程會徹底銷毀。

waitpid:與wait不同的是，

a.可以表示四種不同的子進程類型

     pid==-1 等待任何一個子進程，此時waitpid的作用與wait相同

　　pid >0 等待進程ID與pid值相同的子進程

　　pid==0 等待與調用者進程組ID相同的任意子進程

　　pid<-1 等待進程組ID與pid絕對值相等的任意子進程

b.當options的值為WNOHANG時，為非阻塞模式，即waitpid會立即返回

此時，可以循環查詢子進程的狀態，若子進程未結束，waitpid返回，做其他工作。

這樣提高了程序的效率。

wait函數使用示例如下：

process_fork3.c

#include<wait.h>
#include<stdio.h>
#include<sys/types.h>
int main()
{
  pid_t pid = fork();
  int stat = 0;
  switch(pid)
  {
    case -1:
      perror("fork failed");
      exit(1);
      break;
    case 0:
      printf("\n");
      exit(0);
      break;
    default:
      pid = wait(&stat);
      printf("Child has finished:PID=%d\n",pid);
      printf("parent,ps done\n");
      break;
  }
  exit(0);
}

輸出結果：

waitpid函數使用示例如下：

process_fork2.c

#include<wait.h>
#include<stdio.h>
#include<sys/types.h>
int main()
{
  pid_t pid = fork();
  int stat = 0;
  switch(pid)
  {
    case -1:
      perror("fork failed");
      exit(1);
      break;
    case 0:
      printf("\n");
      execlp("ps","ps","au",0);
      break;
    default:
      do
      {
        pid = waitpid(pid,&stat,WNOHANG);
        if(pid==0)
        {
          printf("parent do something else.\n");
          sleep(1);
        }
      }while(pid==0);
      printf("Child has finished:PID=%d\n",pid);
      printf("parent,ps done\n");
      break;
  }
  exit(0);
}

輸出結果：

4.啟動新進程三種方法的比較

1)system函數最簡單，啟動shell進程，并在shell進程中執行新的進程。

效率不高，system函數必須等待子進程返回才能接著執行。

2)exec系列函數用新進程替換掉原進程，但不會返回到原進程，除非調用失敗。

該函數繼承了許多原進程的特性，效率也較高。

3)fork函數，復制一個子進程，和父進程一模一樣，但是擁有自己的內存空間。父子進程執行互不影響。需要注意僵尸子進程的問題。

關于“Linux如何啟動新進程”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。