Linux进程控制知识总结

浏览数：30 / 时间：2015年06月20日

一：进程标识符(ID)

二：进程操作

2.1创建一个进程

2.2 fork函数出错情况

2.3创建一个共享空间的子进程

2.4退出程序

2.5设置进程所有者

三：执行程序

3.1 exec函数

3.2 执行解释器文件

3.3在程序中执行Shell命令

四：关系操作符

4.1等待进程退出

4.2 等待指定的进程

进程控制

—— 一步

一：进程标识符(ID)

进程ID是用来标识进程的编号，就像身份证一样。不同的进程有不同的ID，可以通过ID来查询进程。进程标识符的类型是pit_t，其本质是一个无符号整型。使用ps命令可以查看当前进程。

每一个进程有6个重要的ID值：

进程ID；

父进程ID；

有效用户ID；

有效组ID；

实际用户ID；

实际组ID；

Linux下使用下列函数可以获得相应的ID：

#include<unistd.h>

pid_t getpid(void); //得到进程ID

pid_t getppid(void); //得到父进程ID

uid_t getuid(void); //得到实际用户ID

uid_t geteuid(void); //得到有效用户ID

gid_t getgid(void);

gid_t getegid(void);

上述几个函数成功则返回相应的ID，失败则返回-1。

示例：

/*打印相关进程信息*/

#include<stdio.h>

#include<unistd.h>

int main()

{

pid_t pid,ppid,uid,euid,gid,egid;

pid=getpid();

ppid=getppid();

uid=getuid();

euid=geteuid();

gid=getgid();

egid=getegid();

printf("id of current process:%u",pid);

printf("parent id of current process:%u",ppid);

printf("user of current process:%u",uid);

printf("effective user of current process:%u",euid);

printf("group id of current process:%u",gid);

printf("effective group id of current process:%u",egid);

return 0;

}

/*END*/

/*************************分隔符********************************/

二：进程操作

2.1创建一个进程

使用函数fork可以创建一个新进程：

#include<unistd.h>

pid_t fork(void);

返回值有3种情况：

1.对于父进程，fork函数返回新创建的子进程的ID；

2.对于子进程，fork函数返回0。由于系统的0号进程是内核进程，因此子进程的进程号不可能为0。由此区别父进程和子进程。

3.如果出错，返回-1。

fork创建的是子进程，其完全复制了父进程的地址空间的内容，包括堆栈段和数据段的内容。

子进程并没有复制代码，而是和父进程共用代码段。

简言之：子进程地址空间完全和父进程分开。父子进程是两个独立的进程，接收系统调用的机会相等。

示例：

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

int global; //全局变量，默认初值为0

int main()

{

pid_t pid;

int stack=1;

int *heap;

heap=(int *)malloc(sizeof(int));

*heap=2;

pid=fork(); //创建一个子进程

if(pid<0){

printf("fail to fork!\n");

exit(1);

}else if(pid==0){

global++;

stack++;

(*heap)++;

printf("the chid,global:%d,stack,%d,heap,%d\n",global,stack,*heap);

exit(0);

} //子进程运行结束

sleep(2);/*由于父子进程并列，被运行的几率相等，因此此处将父进程延时2s，以让子进程先运行*/

printf("the parent,global:%d,stack.%d,heap,%d\n",global,stack,*heap);

return 0;

}

/*END*/

运行结果：

the child,global:1,stack:2,heap:3

the parent,global:0,stack:1,heap:2

可见，在子进程里改变了变量的值，但并没有影响父进程变量的值。上面已经说过，子进程复制父进程地址空间里面的内容，即会将global,stack,heap复制到自己的地址空间，其地址空间是另外开辟的，与父进程的地址空间并列。因此子进程改变变量的值只是在自己的地盘改变，并不会影响到父进程地址空间

里的变量值。

2.2 fork函数出错情况

fork出错将返回-1，有两种情况可能导致fork函数出错：

1.系统中已经有太多的子进程存在；

2.调用fork函数的用户的进程太多了。

下面示例出错即是因为创建过多进程使系统奔溃：

示例：

#include<unistd.h>

#include<stdio.h>

int main()

{

while(1)

fork();

return 0;

}

/*END*/

程序将不断创建新的子进程，直至导致系统奔溃。

2.3创建一个共享空间的子进程

Linux下提供一个和fork函数类似的函数，也可以用来创建一个公用父进程地址空间的子进程，其函数原型如下：

#include<unistd.h>

pid_t vfork();

vfork与fork函数区别如下：

1.vfork函数产生的子进程和父进程完全共享地址空间，包括代码段，数据段和堆栈段，子进程对这些共享资源的修改可以影响到父进程。

2.vfork函数产生的子进程一定比父进程先运行，也就是说，父进程调用了vfork函数之后会等待子进程运行后再运行。

示例：

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

int global; //全局变量，默认初值为0

int main()

{

pid_t pid;

int stack=1;

int *heap;

heap=(int *)malloc(sizeof(int));

*heap=2;

pid=vfork(); //创建一个子进程

if(pid<0){

printf("fail to fork!\n");

exit(1);

}else if(pid==0){

global++;

stack++;

(*heap)++;

printf("the chid,global:%d,stack,%d,heap,%d\n",global,stack,*heap);

exit(0);

} //子进程运行结束

sleep(2);/*由于父子进程并列，被运行的几率相等，因此此处将父进程延时2s，以让子进程先运行*/

printf("the parent,global:%d,stack.%d,heap,%d\n",global,stack,*heap);

return 0;

}

/*END*/

运行结果：

the child,global:1,stack:2,heap:3

the parent,global:1,stack:2,heap:3

可见，子进程对变量的修改影响了父进程。这里有点类似指针的概念，子进程就像指向父进程的指针，其直接操作父进程地址空间里面的内容并且有效。

另外，值得注意的是，不要在任何函数（除主函数）的内部调用vfork，这样会导致段错误。（自己思考为何）

2.4退出程序

进程退出时需要用到退出函数：

#include<stdlib.h>

void exit(int status);

参数status表示退出状态，是个整值。利用exit(1),exit(2)...这样的设置可以方便我们调试程序。

另外Linux内核封装了_exit函数，它与exit的主要区别是：exit会做一些善后工作，比如清理I/O缓冲区，释放用户进程的地址空间等；而_exit函数则直接进入内核，释放用户进程的地址空间，所有用户空间的缓冲区内容都将丢失。

2.5设置进程所有者

Linux下可以改变进程用户的ID：

#include<unistd.h>

int setuid(uid_t uid); //修改实际用户ID和有效用户ID

int seteuid(uid_t uid); //只修改有效用户ID

成功返回0，失败返回-1。

示例：

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

int main()

{

uid_t uid;

uid_t euid;

uid=getuid();

euid=geteuid();

printf("the uid is:%d\n",uid);

printf("the euid is:%d\n",euid);

if(setuid(1000)==-1)

{

printf("fail to set uid!");

exit(1);

}

printf("after changing:\n");

uid=getuid();

euid=geteuid();

printf("the uid is:%d\n",uid);

printf("the euid is:%d\n",euid);

return 0;

}

/*END*/

/*************************分隔符********************************/

三：执行程序

3.1 exec函数

下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec函数族。系统调用execve（）对当前进程进行替换，替换者为一个指定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变量（envp）。exec函数族当然不止一个，但它们大致相同。下面对exec函数做简要介绍：

1）execl()

int execl(const char *path, const char *argv.......);

函数执行成功则不返回，否则返回-1

功能：execl()用于执行参数path字符串代表的文件路径，接下来参数代表执行文件时传递argv,最后一个参数必须以空指针结束。

2）execle()

int execle(const char *path, const char *argv.....，const char *envp[])

功能：执行那个参数path字符代表的文件路径，接下来参数代表执行文件时传递的参数argv，最后一个参数必须指向一个新的环境变量数组，成为新执行程序的环境变量。

3)execlp()

int execlp(const char *path, const char *arg......)

功能：从path环境变量所指目录中查找符合参数file的文件名，找到后执行该文件，接下来参数代表执行文件时传递的argv[0],最后一个参数必须以空指针NULL。

4）execv()

int execv(const char *path, const char *arg[])

功能：执行参数path字符代表的文件路径，第二参数以数组指针来传递给执行文件。

5）execve()

int execve(const char *filename, const char *argv[], const char *envp[])

功能:执行filename字符串代表的文件路径，中间参数利用数组指针来传递给执行文件，最后一个参数为传递给执行文件的新环境变量数组。

6）execvp()

int execvp(const char *filename, const char *argv[])

功能:从path环境变量所指定目录中查找符合参数file的文件名, 找到后执行此文件，第二个参数argv传递给要执行的文件。

当fork创建新进程时，即可使用exec函数执行新的程序，但并不是创建新的进程。一个进程一旦调用exec类函数，它本身就"死亡"了，系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数据段与堆栈段，唯一留下的，就是进程号，也就是说，对系统而言，还是同一个进程，不过已经是另一个程序了。

示例：

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

int main(void)

{

pid_t pid;

pid=fork(); //创建子进程

if(pid<0)

{

printf("fail to fork!");

exit(1);

}

else

if(pid==0) //子进程

{

/*调用exec函数，运行当前目录下的setuid程序*/

if(execvp("hello",NULL)==-1)

{

printf("fail to exec!\n");

exit(0);

}

/*这里应该永远不会执行，因为调用exec后这里的代码被setuid程序取代了*/

printf("the child is not hello!\n");

exit(0);//子进程正常退出

}

printf("the parent!\n"); //父进程

return 0;

}

/*END*/

其中hello为输出“hello world”的可执行程序。

运行输出：

hello world

the parent!

可见运行exec函数后的子进程将被加载的hello程序替换，直至子进程运行结束。

3.2 执行解释器文件

Linux中可执行文件分为两种，一种是二进制可执行文件，这种文件经过编译系统编译链接后生成。另一种是解释器文件，这种文件不是二进制的，而是一般的文本文件。这种文件起始形式为：

#！解释器程序的路径解释器程序所需要的参数

例如Linux环境下使用的Shell脚本，其脚本的起始形式为：

#！/bin/sh

除去第一行以外的文件内容都被认为是解释器文件的内容，其处理交由定制的解释器程序处理。

此处只是粗略介绍，详细知识请查阅有关资料。

3.3在程序中执行Shell命令

Linux环境下使用system调用Shell指令：

#include<stdlib.h>

int system(const char *cmdstring);

下面是使用ls命令写到文件并读出显示的程序：

示例：

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<fcntl.h>

#define MAX 1024

int main()

{

int fd,n;

char buf[MAX];

if(system("ls > temp.txt")==-1)

{

printf("fail to exec command!\n");

exit(1);

}

if((fd=open("temp.txt",O_RDWR))==-1)

{

printf("fail to open!\n");

exit(1);

}

if((n=read(fd,buf,MAX))==-1)

{

printf("fail to read!\n");

exit(1);

}

buf[n]=‘\0‘;

printf("%s",buf);

return 0;

}

/*END*/

该程序将ls命令执行结果写入temp.txt之中，之后再从temp.txt当中读取输到屏幕显示。其作用效果与直接执行ls命令一样。

system函数的实现：

system函数的执行流程分两步，首先调用system函数的进程创建出一个子进程，并调用wait函数等待子程序执行完毕；然后由这个子进程调用exec函数加载shell运行cmdstring中指定的命令，根据该流程可以编写一个system函数的实现原理性实现程序。

#include<sys/wait.h>

#include<stdio.h>

#include<unistd.h>

int sys(const char *cmdstring)

{

pid_t pid;

int status;

if(cmdstring==NULL) return 1;

pid=fork();

if(pid<0) status=-1;

else if(pid==0)

{

execl("/bin/sh","sh","-c",cmdstring,NULL);

_exit(127);

}

if(waitpid(pid,&status,0)==-1) status=-1;

return status;

}

/*END*/

/*************************分隔符********************************/

四：关系操作符

4.1等待进程退出

Linux下使用wait函数得到子进程结束的信息：

#include<sys/wait.h>

pid_t wait(int *statloc);

调用wait函数会使进程阻塞，直到该进程的任意一个子进程结束。statloc用来保存子进程的返回信息，内核将会取得的子进程结束信息保存在该指针所指向的空间。如果指针为NULL，则表示用户对返回信息并不关心。

返回信息是一个整数，不同的位代表不同的信息：正常结束状态，终止进程的信号编号和暂停进程的信号编号。Linux系统定义了专门的宏，用来判断哪种状态有效并取得相应的状态值。

状态判断宏取值宏

正常结束 WIFEXITED(status) WEXITSTATUS(status)

异常终止 WIFSIGNALED(status) WTERMSIG(status)

进程暂停 WIFSTOPPED(status) WSTOPSIG(status)

例如，当一个程序正常退出时，该进程父进程得到它返回信息，此时需要判断：如果WIFEXITED(status)为真，则该进程是正常退出，WEXITSTATUS(status)返回进程结束状态信息。

示例：

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<sys/wait.h>

int main()

{

pid_t pid;

int status;

pid=fork();

if(pid<0){

printf("fail to fork!\n");

exit(1);

}else if(pid==0)

{

printf("exit normally!\n");

exit(0);

}

if(wait(&status)==-1){

printf("fail to wait!\n");

exit(1);

}

if(WIFEXITED(status)==1)

printf("the status is:%d\n",WTERMSIG(status));

return 0;

}

/*END*/

4.2 等待指定的进程

需要等待指定进程需要用到：

#include<sys/wait.h>

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

第一个参数为要等待子进程的ID，第三个是控制选项：

wait函数选项选项说明

WCONTINUED 当子进程在暂停后继续执行，且其状态尚未报告，则返回其状态

WNOHANG 当等待的进程未结束运行时不阻塞，waitpid函数直接返回

WUNTRACE 当子进程暂停时，并且其状态自暂停以来还未报告过，则返回其状态

僵尸进程：

1). 僵尸进程概念：

就是已经结束了的进程，但是没有从进程表中删除。太多了会导致进程表里面条目满了，进而导致系统崩溃，倒是不占用系统资源。在进程的状态中，僵尸进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集。

除此之外，僵尸进程不再占有任何内存空间。它需要它的父进程来为它收尸，如果他的父进程没安装SIGCHLD信号处理函数调用wait或waitpid()等待子进程结束，又没有显式忽略该信号，那么它就一直保持僵尸状态，如果这时父进程结束了，那么init进程自动会接手这个子进程，为它收尸，它还是能被清除的。但是如果如果父进程是一个循环，不会结束，那么子进程就会

一直保持僵尸状态，这就是为什么系统中有时会有很多的僵尸进程。

2).僵尸进程产生的原因：

每个 Linux进程在进程表里都有一个进入点（entry），核心程序执行该进程时使用到的一切信息都存储在进入点。当用ps命令察看系统中的进程信息时，看到的就是进程表中的相关数据。

当以fork()系统调用建立一个新的进程后，核心进程就会在进程表中给这个新进程分配一个进入点，然后将相关信息存储在该进入点所对应的进程表内。这些信息中有一项是其父进程的识别码。当这个进程走完了自己的生命周期后，它会执行exit()系统调用，此时原来进程表中的数据会被该进程的退出码（exit code）、执行时所用的CPU时间等数据所取代，这些数据会一直保留到系统将它传递给它的父进程为止。由此可见，进程的出现时间是在子进程终止后，但是父进程尚未读取这些数据之前。

3).僵尸进程的查看：

用 top命令，可以看到

Tasks: 123 total, 1 running, 122 sleeping, 0 stopped, 0 zombie

zombie前面的数量就是僵尸进程到数量；

ps -ef

出现：

root 13028 12956 0 10:51 pts/2 00:00:00 [ls] <defunct>

最后有 defunct的标记，就表明是僵尸进程。

4).僵尸进程解决办法：

4.1 改写父进程，在子进程死后要为它收尸。具体做法是接管SIGCHLD信号。子进程死后，会发送SIGCHLD信号给父进程，父进程收到此信号后，执行 waitpid()函数为子进程收尸。

这是基于这样的原理：就算父进程没有调用wait，内核也会向它发送SIGCHLD 消息，尽管对的默认处理是忽略，如果想响应这个消息，可以设置一个处理函数。

4.2 把父进程杀掉。父进程死后，僵尸进程成为"孤儿进程"，过继给1号进程init，init始终会负责清理僵尸进程．它产生的所有僵尸进程也跟着消失。