《unix环境高级编程》 读书笔记 (7)

目录: http://blog.csdn.net/alex_my/article/details/39346381

process control


1 process identifiers

每一个进程都有一个唯一的非负整型做为标识符。

#include

pid_t getpid();
pid_t getppid();

pit_t getuid();
pit_t geteuid();

pit_t getgid();
pit_t getegid();

getpid: 返回进程ID
getppid: 返回父进程ID

getuid: 获得进程的real user ID
geteuid: 获得进程的effective user ID

关于real user ID和effective user ID:
Advanced Programming in the UNIX Environment (2) 第三节,链接:
http://blog.csdn.net/alex_my/article/details/39184461

getgid: 获取进程的real group ID
getegid: 获取进程的effective group ID

它们的用法在本文的后续章节中出现。


2 fork function

#include

pid_t fork(void);

创建一个新的子进程,这个函数一次调用,两次返回,在原进程(即未来的父进程)中,返回的值为子进程ID,在子进程中,返回的值为0。子进程只能拥有一个副进程,可以通过getppid获取到父进程的ID。

理论上来说,子进程会复制一份父进程的数据空间,堆,栈。但是,往往在程序中,执行fork之后,常常在子进程中调用exec,该子进程完全由新的程序替换,覆盖了原先子进程复制的这部分数据空间,堆,栈,使得之前的复制白费力。因此,在大部分的实现中,子进程并不立马拷贝一份,而是使用一种"copy-on-write",当哪个进程要改变某一小部分内容的时候,就将小部分内存拷贝一份,供其使用。

至于子进程具体继承了什么,不继承什么,可以查询man 2 fork。

继承部分:
real user ID, effective user ID, real group ID, effective group ID
supplementary group IDs
process group ID
session ID
controlling terminal
ser-user-ID and set-group-ID flags
current working directory
root directory
file mode creation mask
signal mask and dispositions
the close-on-exec flag for any open file descriptors
environment
attached shared memory segments
memory mappings
resource limit


不继承部分:
child's tms_utime, tms_stime, tms_cutime, and tms_cstime are set to zero
file locks
pending alarms are cleared for the child
the set of pending signals for the child is set to the empty set


程序用例:

#include
#include
#include
#include
#include

int main(int argc, char* argv[])
{
     int n = 1;

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

     printf("test stdio buffer ");

     pid_t pid = fork();
     if(pid < 0)
     {
          printf("fork failed, error[ %d ] \t [ %s ]\n", errno, strerror(errno));
          exit(EXIT_FAILURE);
     }

     if(pid == 0)
     {
          printf("children, pid: %d \t ppid: %d \n", getpid(), getppid());
          ++n;
     }
     else
     {
          printf("parent, pid: %d \t ppid: %d \n", getpid(), getppid());
     }

     printf("n: %d \n", n);

     return 0;
}

输出:

process id: 7328 
test stdio buffer parent, pid: 7328 ppid: 4766 
n: 1 
test stdio buffer children, pid: 7329 ppid: 7328 
n: 2 

在fork()前调用的语句printf("test stdio buffer ")被执行了两次。这是因为,当标准输出是终端设备的时候,是行缓冲的,否则,是全缓冲。
当把"test stdio buffer "填入输出缓冲区的时候,并没有flush到终端,接下来子进程复制了这部分,因此会输出两次。
当句子改为:printf("test stdio buffer \n")的时候,仅输出一次,因为换行引起flush。


3 vfork function

vfork产生一次新进程,与fork不同的是:
-1:父子进程共享数据空间,在程序用例中有体现
-2: 子进程先运行,直到子进程调用exec或者退出后,父进程才会运行,如果子进程在运行过程中,需要等待父进程接下来运行的某个状态或者数值,则会死锁。

修改下fork的程序用例:

#include
#include
#include
#include
#include

int main(int argc, char* argv[])
{
     int n = 1;

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

     pid_t pid = vfork();
     if(pid < 0)
     {
          printf("fork failed, error[ %d ] \t [ %s ]\n", errno, strerror(errno));
          exit(EXIT_FAILURE);
     }
     
     if(pid == 0)
     {
          printf("children, pid: %d \t ppid: %d \n", getpid(), getppid());
          ++n;
          printf("n: %d \n", n);
          _exit(0);
     }
     else
     {
          printf("parent, pid: %d \t ppid: %d \n", getpid(), getppid());
          printf("n: %d \n", n);
     }

     exit(EXIT_SUCCESS);
}

输出:

process id: 7893 
children, pid: 7894 ppid: 7893 
n: 2 
parent, pid: 7893 ppid: 6718 
n: 2 

由于父子进程共享数据空间,因此,父进程中的n也为2(其实是同一个n)

需要注意的是,子进程中终止进程采用的是_exit(0)。由前面的章节得知,_exit并不会flush标准流。
如果子进程中,调用exit(0),而系统实现exit中会关闭标准I/O流,由于二者共享空间,那么父进程调用printf的时候,就不会产生输出。

不过,现在大多是的实现中,不会在exit中关闭标准I/O流,因为进程即将关闭,内核将关闭所有打开的文件描述符,因此,不必在exit中多此一举。所以,如果子进程中使用exit终止进程,编译运行,也会正常。


4 exit

exit相关已经在BOOKS: Advanced Programming in the UNIX Environment (6)第一节有所描述。

进程退出,释放所占用的资源,包括打开的文件描述符,申请的内存等,但是仍然保留了一定的信息,包括进程号,终止状态,运行时间等。直到父进程调用wait/waitpid来获取才会释放。

如果一个进程,大量产生子进程,等待子进程结束之后,缺不主动调用wait/waitpid去释放子进程的保留信息,就会造成不良后果,比如进程号被占用(系统所能使用的进程号是有限的),积累到一定程度后,会造成进程由于进程号限制而创建失败。

有一些退出的情况:

-1: 当父进程在子进程之前退出,即子进程失去了父亲,成为了孤儿进程,这时候,init进程就会收养这些孤儿进程,并且循环调用wait来释放已经推出的子进程。

-2: 当子进程先于父进程退出,释放一定的资源后,还会留下一些信息,此时的子进程称为僵尸进程。这些信息由父进程调用wait/waitpid后才会释放。子进程在退出的时候,会发送SIGCHLD信号给父进程,父进程接到信号后,在信号处理函数中调用wait/waitpid处理这些僵尸进程。默认情况下,父进程是忽略这些信号的。

程序用例在下一节中。


5 wait and waitpid functions

无论一个进程是正常结束还是异常终止,内核都会发送SIGCHLD信号给其父进程。子进程的终止是一个异步事件,可能发生在父进程运行的任何时候。内核通过信号异步通知父进程,父进程接到该信号后,可以选择忽略和处理。默认情况下是忽略该信号。父进程在信号处理函数中,可以调用以下两个函数之一来释放子进程退出后还保留的信息。

#include

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

wait: 阻塞当前进程,直到有信号来或者子进程结束,如果在调用时子进程已经结束,则wait()会立即返回子进程的结束状态值。子进程的状态值由stat_loc返回。返回值为已结束的子进程ID。

waitpid: 阻塞当前进程,直到有信号来或者子进程结束,子进程状态值由stat_loc返回。

参数pid可选值:

< -1: 等待进程组识别码为pid绝对值的任何子进程
= -1: 等待任何子进程,相当于wait()
= 0 : 等待进程组识别码与当前进程相同的任何子进程
> 0 : 等待指定进程ID的子进程

参数options可选值:

0           : 

WCONTINUED  : 如果指定pid从作业控制暂停中继续,则返回。

WNOHANG     : 如果指定Pid的进程没有结束,也不阻塞,立即返回。

WUNTRACED   : 如果子进程进入暂停状态,则马上返回,不理会其结束状态。


对于返回的状态值,可以调用以下宏进行进一步判断(真,非零值):

WIFEXITED   : 如果为正常结束的子进程返回的状态,则为真

WEXITSTATUS : 对于正常结束的子进程,可以取得子进程退出状态的低八位

WIFSIGNALED : 如果是信号结束的子进程状态,则为真

WTERMSIG    : 对于信号结束的子进程,可以取得使子进程结束的信号编码

WIFSTOPPED  : 如果当前子进程是暂停而返回的,则为真

WSTOPSIG    : 对于暂停而返回的子进程,可以取得使子进程暂停的信号编码

WIFCONTINUED: 如果当前子进程是从一个作业控制暂停中继续的,则为真

程序用例1:父进程先退出

#include
#include
#include
#include
#include // strerror

int main(int argc, char* argv[])
{
     pid_t pid = fork();

     if(pid < 0)
     {
          printf("fork failed. error[%d] \t %s \n", errno, strerror(errno));
          exit(EXIT_FAILURE);
     }

     if(pid == 0)
     {
          printf("child process, pid: %d \t ppid: %d\n", getpid(), getppid());
          sleep(5);
          printf("child process, pid: %d \t ppid: %d\n", getpid(), getppid());
          exit(EXIT_SUCCESS);
     }
     else
     {
          printf("father process\n");
          printf("father exit\n");
     }

     exit(EXIT_SUCCESS);
}

输出:

father process
father exit
child process, pid: 10471   ppid: 10470
child process, pid: 10471   ppid: 1

父进程退出后,子进程被托管给了init(process ID为1)

程序用例2:子进程先退出,父进程不处理

#include
#include
#include
#include
#include // strerror

int main(int argc, char* argv[])
{
     pid_t pid = fork();

     if(pid < 0)
     {
          printf("fork failed. error[%d] \t %s \n", errno, strerror(errno));
          exit(EXIT_FAILURE);
     }

     if(pid == 0)
     {
          printf("child process, pid: %d \t ppid: %d\n", getpid(), getppid());
          exit(EXIT_SUCCESS);
     }
     else
     {
          printf("father process, pid: %d\n", getpid());
          sleep(10); // 方便查看僵尸进程
          printf("father exit\n");
     }

     exit(EXIT_SUCCESS);
}

输出:

程序放后台运行,比如编译出程序为 test8.3, 则执行:./test8.3 &
当运行时,可以输入ps -l

[1] 10727
father process, pid: 10727
child process, pid: 10731   ppid: 10727
[alex_my@localhost Apue]$ ps -l
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1000 10344  8837  0  80   0 - 29164 wait   pts/1    00:00:00 bash
0 S  1000 10727 10344  0  80   0 -  3122 hrtime pts/1    00:00:00 test8.3
1 Z  1000 10731 10727  0  80   0 -     0 exit   pts/1    00:00:00 test8.3
0 R  1000 10732 10344  0  80   0 - 30315 -      pts/1    00:00:00 ps

father exit

可以发现,子程序退出后,成为了僵尸进程,注意Z符号。

程序用例3:子进程先退出,父进程通过信号处理

clude
#include
#include
#include // strerror
#include
#include

// 信号处理函数
static void sig_process(int signo)
{
     int status;
     pid_t pid = wait(&status);
     printf("child[%d] terminated\n", pid);
}

int main(int argc, char* argv[])
{
     signal(SIGCHLD, sig_process);

     pid_t pid = fork();
     if(pid < 0)
     {
          printf("fork failed. error[%d] \t %s \n", errno, strerror(errno));
          exit(EXIT_FAILURE);
     }

     if(pid == 0)
     {
          printf("child process, pid: %d \t ppid: %d\n", getpid(), getppid());
          exit(EXIT_SUCCESS);
     }
     else
     {
          printf("father process, pid: %d\n", getpid());
          sleep(10); // 等待子进程退出及ps -l
          printf("father exit\n");
     }

     exit(EXIT_SUCCESS);
}


输出:

[1] 11013
father process, pid: 11013
child process, pid: 11017   ppid: 11013
child[11017] terminated
father exit
[1]+  Done                    ./test8.3
[alex_my@localhost Apue]$ ps -l
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1000 10344  8837  0  80   0 - 29164 wait   pts/1    00:00:00 bash
0 R  1000 11018 10344  0  80   0 - 30315 -      pts/1    00:00:00 ps

可以看见,没有发现Z开头的僵尸进程了。当然,如果你够快,在子进程结束到父进程处理之前输入ps -l 还是可以发现的。
比如在把父进程退出时间改为20秒,在信号处理函数里边添加一句 sleep(10), 则在子进程退出后10秒内输入ps -l,还是能看见僵尸进程的。


6 waitid function

#include

int waitid(idtype_t idtype, id_t id, siginfo_t* infop, int options);

如同waitpid, 但id意义依赖于idtype。

idtype可选值:

P_PID : id为指定子进程ID
P_PGID: 指定进程组ID,该组下的子进程均符合条件
P_ALL : 任意子进程, id无效

options与waitpid中的参数options相同。

infop结构包含:

si_pid   : process ID
si_uid   : real user ID or 0
si_signo : SIGCHLD
si_status: exit status or signal
si_code  : CLD_EXITED(_exit), CLD_KILLED(killed by signal), CLD_DUMPED(killed by signal, and dump core),
CLD_STOPPED(stopped by signal), CLD_TRAPPED(traced child has trapped), CLD_CONTINUED(child continued by SIGCONT)

程序用例:

将前边代码中的信号处理函数修改如下:

static void sig_process(int signo)
{
     sleep(10);
     int status;
     siginfo_t info;

     pid_t pid = waitid(P_ALL, 0, &info, 0);

     printf("child process, pid: %d \t ppid: %d\n", getpid(), getppid());
     printf("child[%d] terminated\n", pid);

     printf("info: si_pid: %d \t si_uid: %d\n", info.si_pid, info.si_uid);
     printf("info: si_code: %d\n", info.si_code);
}

然后运行,可以看到结果。




你可能感兴趣的:(APUE)