精华内容
下载资源
问答
  • 【单选题】下面叙述中,正确的是()A. 线程是比进程更小的能独立运行的基本单位,可以脱离进程独立运行 B. 引入线程可提高程序并发执行的程度,可进一步提高系统效率 C. 线程的引入增加了程序执行时更多相关问题...

    【单选题】下面的叙述中,正确的是()

    A. 线程是比进程更小的能独立运行的基本单位,可以脱离进程独立运行 B. 引入线程可提高程序并发执行的程度,可进一步提高系统效率 C. 线程的引入增加了程序执行时

    更多相关问题

    [单选] 离合器上安装扭转减振器是为了防止()。

    [判断题] 最早将社会制度的功能从性质上做这种区分的是美国社会学家默顿。

    [判断题] 最早将社会制度的功能从性质上做这种区分的是美国社会学家默顿。

    [填空题] 缩宫素酶的作用为______,其活性降低见于______、______、______

    [多选] 技术转让合同包含()合同。

    [填空题] 妊娠早期的羊水主要来自______,中期以后______为羊水的重要来源

    [单选] 着火点是能产生燃烧现象所需要的()温度。

    [多选] 生产过程一般是由许多部分组成,根据各部分在生产过程中的作用不同可划分为()。

    [多选] 在赠与合同中规定受赠人有(),赠与人可以撤销赠与。

    [填空题] 一个初级绒毛干及其分支形成一个______,一个次级绒毛干及其分支形成一个______。

    [问答题] 哪一次会议提出实行改革开放的伟大决策?

    [填空题] 胎盘的功能包括_____________、______________、___________、_________以及_________

    [填空题] 受精卵着床需经过_____、_____和_____3个阶段。

    [单选] 废气再循环的目的是净化排气中()。

    [单选] 导线振动是由线路侧面吹来的均匀微风造成的,这种风速是()m/s。

    [填空题] 受精卵着床需经过_____、_____和_____3个阶段。

    [判断题] 对于一个具有三级索引表的文件,存取一个记录需要访问三次磁盘。

    [单选] 工商银行“汇市通”业务可提供从()每日24小时外汇交易服务。

    [单选] 如果批量退货中发生实际退货商品的数量或条形码与批量退货登记表上填写的数量或条形码不相符的情况时,下列哪项操作是正确的()

    [判断题] 对于一个具有三级索引表的文件,存取一个记录需要访问三次磁盘。

    [判断题] 存取控制表是每个用户一张,表明该用户对不同文件的存取权限。

    [填空题] 受精卵着床需经过_____、_____和_____3个阶段。

    [单选] 瑞士联邦共和国实行()

    [单选] 01,11,15,30、31分区、28分区的01、92、96部门的同事收到采购发出的Bulletin后,必须在()天内将索赔退货商品送往索赔办。

    [问答题] 简述苹果施肥时期和方法

    [填空题] 低压带电作业时应站在干燥的绝缘物上进行,并戴()和安全帽。

    [单选] 01,11,15,30、31分区、28分区的01、92、96部门的同事收到采购发出的Bulletin后,必须在()天内将索赔退货商品送往索赔办。

    [判断题] SPOOLing技术可以解决进程使用设备死锁问题。

    [填空题] 胎盘合成的甾体激素有_________和__________等。

    [填空题] 胎儿附属物是指胎儿以______,包括______、______、_____和______。

    [填空题] 缩宫素酶的作用为______,其活性降低见于______、______、______

    [填空题] 孕妇血容量增加于妊娠______周达高峰,血容量增加包括______及______。

    [多选] 生产过程一般是由许多部分组成,根据各部分在生产过程中的作用不同可划分为()。

    [填空题] 妊娠______周胎儿开始出现呼吸运动,______周开始出现吞咽和排尿功能。

    [填空题] 胎儿附属物是指胎儿以______,包括______、______、_____和______。

    展开全文
  • 72-孤儿进程与孤儿进程

    千次阅读 2017-02-26 15:02:51
    之前有学习过僵尸进程,它指的是“未老先衰”的子进程先于父进程去逝,而父进程未对它进行回收(wait)所产生的。本文来谈谈,另一个对立的...下面的代码可以产生一个孤儿进程。int main() { pid_t pid = fork(); if

    之前有学习过僵尸进程,它指的是“未老先衰”的子进程先于父进程去逝,而父进程未对它进行回收(wait)所产生的。

    本文来谈谈,另一个对立的概念——孤儿进程,以及孤儿进程组。

    1. 孤儿进程

    如果一个进程,它的父进程先终止了,则该进程成为孤儿进程。此后,该进程的父进程变为 1 号 init 进程。

    下面的代码可以产生一个孤儿进程。

    int main() {
      pid_t pid = fork();
      if (pid == 0) {
         while(1) sleep(1);
      }
      return 0;
    }

    上面的程序运行后,产生一个子进程,进入死循环,而父进程将会退出,此后子进程被 init 进程回收,成为孤儿进程。

    需要注意的是,孤儿进程不像僵尸进程,它是无害的,也不需要回收。

    2. 孤儿进程组

    整个进程组也可以成为孤儿。POSIX.1 将孤儿进程组定义为:

    该进程组的每个成员的父进程要么是该组的成员,要么在其它会话中。

    只要能够满足上面的定义,则此进程组就是孤儿进程组。可能读起来比较拗口,看图 1 中的例子可能会清楚点。


    这里写图片描述
    图 1 非孤儿进程组与孤儿进程组

    图 1 中,按照孤儿进程组的定义,进程组 1 不是孤儿进程组,因为进程组 1 中有一个进程的父进程不属于进程组 1,也不在另一个会话中。

    进程组 2 是孤儿进程组,因为该组中的每个成员满足定义:每个成员的父进程要么在本组中,要么在其它会话中。

    3. 孤儿进程组的特性

    如果一个进程组包含一个或一个以上的停止的进程,当该进程组变成孤儿进程组时,每个处于停止状态的进程会接收到 SIGHUP 挂断信号,紧接着又会收到 SIGCONT 信号。(以上是 APUE 中的解释)

    注意,在英文原版中是这样叙述的:

    Since the process group is orphaned when the parent terminates, and the process group contains a stopped process, POSIX.1 requires that every process in the newly orphaned process group be sent the hang-up signal (SIGHUP) followed by the continue signal (SIGCONT).

    上面的大意是说,刚产生的孤独进程组中的每一个进程,而不是每一个停止的进程,是每一个进程都能收到 SIGHUP 信号。中文翻译版本的确有点坑爹啊!!!

    在 Ubuntu 和 Red Hat 中的测试结果也验证了原版中的解释,如果进程组存在停止状态的进程,当该进程组变成孤儿进程组时,该进程组中所有进程都会收到 SIGHUP 信号。其它系统中并未测试,如果你的结果和此不一样,请在下文留言。

    4. 实验

    下面的程序功能:进程组中存在停止的进程,该进程组成为孤儿进程组后,该进程组所有的进程会收到 SIGHUP 信号。另外,该程序还演示了后台进程组试图读控制终端会产生错误。

    需要注意的是,父进程终止,子进程进入后台进程组。

    • 代码
    // orphan.c
    #include <unistd.h>
    #include <stdio.h>
    #include <signal.h>
    #include <stdlib.h>
    #include <errno.h>
    
    void handler(int sig) {
      printf("hello sighup, pid = %d\n", getpid());
    }
    
    void print(char *name) {
      printf("%s: pid = %d, ppid = %d, pgrp = %d, tpgrp = %d\n", 
          name, getpid(), getppid(), getpgid(getpid()), tcgetpgrp(0));
      fflush(stdout);
    }
    
    int main() {
      char c;
      pid_t pid;
      print("parent");
    
      pid = fork();
      if (pid < 0) {
        perror("fork");
      }   
      else if (pid > 0) {
        sleep(5);
      }
      else {
        print("child");
        signal(SIGHUP, handler);
        kill(getpid(), SIGTSTP); // 让子进程暂停
        print("child"); // 如果执行了此行,说明已经收到了 SIGHUP 信号
    
        if (read(STDIN_FILENO, &c, 1) != 1) {
          printf("read error, error number: %d\n", errno);
        }   
        exit(0);
      }
      return 0;
    }
    • 编译和运行
    $ gcc orphan.c
    $ ./orphan
    • 结果


    这里写图片描述
    图2 运行结果

    上面的结果正是预期的。

    程序一开始让父进程打印信息,接着 fork 出子进程,让子进程打印信息,然后子进程进入停止状态。

    等待父进程结束后,子进程所在的组变成了孤儿进程组,同时它也是后台进程组。接着所有子进程会收到 SIGHUP 信号,因为子进程对该信号进行了捕获,信号处理函数向控制终端输出 hello sighup, pid = 3080.

    接下来子进程继续执行 print 向屏幕输出信息,注意此时的前台进程组 tpgrp = 3056,这是 bash 进程所在的进程组 id,也等于 bash 进程的 id.

    最后,子进程试图读控制终端,于是收到 SIGTTIN 信号,read 返回出错,errno 被设置为 5,也就是 EIO,解释如下:

    EIO I/O 错误。当进程位于后台进程组时,还试图从控制终端读,就会产生此错误。

    为了验证其它未停止的进程也能收到信号,你可以多 fork 一个子进程来进行测试。

    5. 总结

    • 理解什么是孤儿进程组
    • 理解进程组中存在和不存在停止的进程的影响

    练习:产生一个孤儿进程组,该进程组中有停止的进程,在程序中捕获 SIGHUP 信号。

    展开全文
  • 总结进程进程组、作业、会话

    千次阅读 2018-05-06 12:59:17
    从以下几个方面叙述进程 进程组 作业 会话 进程进程是操作系统的一个核心概念。每个进程在内核中都有一个进程控制块(PCB)来维护进程信息,这样可以使一个在多道程序环境下不能独立运行的程序成为一个...

    本篇文章主要讲述进程间关系的几个基本概念。从以下几个方面叙述:

    • 进程
    • 进程组
    • 作业
    • 会话

    进程:

    进程是操作系统的一个核心概念。每个进程在内核中都有一个进程控制块(PCB)来维护进程信息,这样可以使一个在多道程序环境下不能独立运行的程序成为一个能独立运行的基本单位或其他进程并发执行的进程。

    Linux内核的进程控制块是task_struct结构体。task_struct是Linux内核的一种数据结构。它会被装载到RAM里并且包含着进程的信息。

    • task_steuct结构体包含了以下内容:

    这里写图片描述

    • 进程ID 为 0 的进程通常是调度进程,常常被称为「交换进程」(swapper)。

    • 进程ID 为 1 的进程是 init 进程,在系统自举过程结束时由内核调用。该进程的程序文件是 /sbin/init 。此进程负责在自举内核后启动一个 Unix 系统。init 通常会读取与系统有关的初始化文件(/etc/rc* 或 /etc/inittab,以及 /etc/init.d/ 中的文件),并将系统启动至某个状态。init 进程不会终止,系统启动后产生的所有进程都由 init 进程衍生而来。

    • task_steuct结构体组织形式:
      这里写图片描述

    • 引申:

    通过上面的介绍,了解了进程的相关概念。
    事实上,每个进程除了有一个进程ID(pid)之外,还属于一个进程组。
    进程组是一个或多个进程的集合,每个进程组有一个唯一的进程组ID(pgid)。

    这里写图片描述


    进程组:

    定义:进程组是一个或多个进程的集合
    引入的原因:用于控制向多个进程进行信号的分发,发给一个进程组是信号会发生给进程组中每一个进程

    一个进程除了有一个进程id之外,他还属于一个进程组。进程组是一个或多个进程的集合。通常,它们与同一个作业相关联,可以接受来自同一终端的各种信号。每个进程组有一个唯一的进程组id。每个进程组都可以有一个组长 i 进程。组长进程的标识是其进程组id等于其进程id。组长进程可以创建一个进程组,创建该组中进程,然后终止。只要在某个进程组中一个进程存在,则该进程组就存在,这与其组长进程是否终止无关。

    • 通俗讲讲
      学校会对学生进行分班管理,假如有一个同学第一个报名,那么他的学号就是1号,他所在班级也是一班,他为这个班的班长,陆陆续续有人报名,学号为2号、3号、4号……,
      那么这个1号同学就是组长进程,这个1班就是进程组,它们的标识符是一样的,后来的进程都属于这个进程组。
      如果有一天这个班长退学了,它不上学了,那么这个1号学号就不复存在了,但是1号班级还在,并且里面的剩下其他同学也还在这个班级内。
      如果剩下的同学也陆陆续续退学了,直到这个班级还剩下一个人,那么这个班级也还仍然存在。
      如果这个班级中所有同学都不上了,一个人也没有了,那么这个班级也就不复存在了。

    经过以上了解,总结以下几点:

    • 进程组长id与进程组id相同。
    • 进程组长可以终止,但进程组不会因此消失。
    • 进程组内只要还有一个进程存在,那么这个进程组就存在。
    • 进程组内所有进程终止,这个进程组就不复存在。

    这里写图片描述


    作业:

    Shell可以进行作业控制,即可以运行一个前台作业和任意多个后台作业,每个作业是都可以是一个或者多个进程。

    作业与进程组的区别:
    如果作业中的某个进程又创建了子进程,则子进程不属于作业。一旦作业运行结束,Shell就把自己提到前台,如果原来的前台进程还存在(如果这个子进程还没终止),它自动变为后台进程组。

    • 作业控制

    jobs:查看当前作业
    fg:将后台作业放回前台
    bg:将前台作业放置后台并运行

    会话:

    定义:Session是一个或多个进程组的集合。通常,一个会话开始于用户登录,终止于用户退出,在此期间该用户运行的所有进程都属于这个会话期。

    会话是一个或多个进程组的集合。一个会话可以有一个控制终端。这通常是登陆到其上的终端设备或伪终端设备。建立与控制终端连接的会话首进程被称为控制进程。一个会话中的几个进程组可被分为一个前台进程组以及一个或多个后台进程组。所以一个会话中,应该包括控制终端,一个前台进程组和任意后台进程组。

    这里写图片描述

    • 可以查看会话id:下图中的SID:
      这里写图片描述

    • 总结:
      梳理一下我们将之前学过的几个概念串在一起:大概画出了下面这张图:
      这里写图片描述
    展开全文
  • 关于linux进程编程的一些笔记整理

    千次阅读 2010-11-22 15:45:00
    关于linux进程编程的一些笔记整理。涉及到通过系统调用对进程的创建控制以及进程间通讯的实现。 Linux系统调用--fork函数详解 功能描述:建立一个子进程。所建立的子进程PID 和 PPID不同于其父进程,同时...

    关于linux进程编程的一些笔记整理。

    涉及到通过系统调用对进程的创建控制以及进程间通讯的实现。
     
    Linux 系统调用 --fork 函数详解
      功能描述:
    建立一个子进程。所建立的子进程 PID PPID 不同于其父进程,同时资源使用被设置为 0 ,文件锁和挂起的信号不被继承。
    Linux 内部, fork 的执行使用 copy-on-write 页面,所以耗费的资源只是拷贝父进程页表,建立唯一子进程 task 结构体的时间和内存。
    用法:  
    #include <sys/types.h>
    #include <unistd.h>
     
    pid_t fork(void);
     
    返回说明:   
    成功执行时,在父进程的线程执行中返回子进程 PID ,在子进程的线程执行中返回 0 。失败时在父进程的语境中返回 -1 errno 被设为以下的某个值   
    EAGAIN
    1. 不能为拷贝父进程的页表和子进程的 task 结构分配足够的内存
    2. 不可能再建立新的子进程,因为调用者已达到 RLIMIT_NPROC 的资源限制,除了调用进程有 CAP_SYS_ADMIN CAP_SYS_RESOURCE 的权限
    ENOMEM :内核内存不足,无法分配必须的数据结构
     
    例子:
     
    #include <stdlib.h>
    #include <stdio.h>
    #include <sys/types.h>
     
    int main(void)
    {
     pid_t pid;
     printf("Before fork .../n");
     
     switch(pid = fork()) {
     case -1:
       printf("Fock call fail/n");
       exit(1);
      
     case 0:
       printf("The pid of child is: %d/n", getpid());
       printf("The pid of child's parent is: %d/n", getppid());
       printf("Child exiting.../n");
       exit(0);
     
     default:
       printf("The pid of parent is: %d/n", getpid());
       printf("the pid of parent's child is: %d/n", pid);
     }
     printf("After fork, program exiting.../n");
     exit(0);
    }
     
    unix/linux 管道通信相关函数
      程序中有如下 Linux 系统调用 :    (1) fork( ): 创建一个进程。 返回值: -1 :创建子进程失败。 0 :子进程得到的返回值。 >0 :父进程得到的返回值,表示子进程号( pid) 创建子进程后,父、子进程执行同一个程序段,但有不同的数据区,子进程继 承父进程的资源。    (2) exit( ): 撤消进程。 若父进程因 wait() 而睡眠,则唤醒父进程。 exit() 撤消子进程时必须通知父 进程。    (3) pipe(fd): 创建一个管道 . fd[0] 为管道的读端 ,fd[1] 为管道的写端。管道用来实现父进程与其子孙进程 之间的通信 , FIFO 方式传送消息。    (4) wait(): 父进程等待子进程撤销。 若子进程尚未撤销 , 父进程睡眠等待 , 子进程撤销时 , 将其唤醒,若子进程已撤 销,父进程不睡眠等待。 )    (5) Sleep(n): 进程睡眠等待 n 秒,交出处理机控制权。
    /*----------------------------------------------------*/
    下面我引一篇在网上找到的文章,对理清概念很有帮助,并且里面提到几个很重要点的。
    我将用红色注明。
    /*----------------------------------------------------*/
    进程管理相关的系统调用
    本文介绍了 Linux 下的进程概念,并着重讲解了与 Linux 进程管理相关的 4 个重要系统调用 getpid,fork,exit _exit ,辅助一些例程说明了它们的特点和使用方法。
    关于进程的一些必要知识
    先看一下进程在大学课本里的标准定义:“进程是可并发执行的程序在一个数据集合上的运行过程。”这个定义非常严谨,而且难懂,如果你没有一下子理解这句话,就不妨看看笔者自己的并不严谨的解释。我们大家都知道,硬盘上的一个可执行文件经常被称作程序,在 Linux 系统中,当一个程序开始执行后,在开始执行到执行完毕退出这段时间里,它在内存中的部分就被称作一个进程。
    当然,这个解释并不完善,但好处是容易理解,在以下的文章中,我们将会对进程作一些更全面的认识。
    Linux 进程简介
    Linux 是一个多任务的操作系统,也就是说,在同一个时间内,可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话,会知道我们大家常用的单 CPU 计算机实际上在一个时间片断内只能执行一条指令,那么 Linux 是如何实现多进程同时执行的呢?原来 Linux 使用了一种称为“进程调度( process scheduling )”的手段,首先,为每个进程指派一定的运行时间,这个时间通常很短,短到以毫秒为单位,然后依照某种规则,从众多进程中挑选一个投入运行,其他的进程暂时等待,当正在运行的那个进程时间耗尽,或执行完毕退出,或因某种原因暂停, Linux 就会重新进行调度,挑选下一个进程投入运行。因为每个进程占用的时间片都很短,在我们使用者的角度来看,就好像多个进程同时运行一样了。
    Linux 中,每个进程在创建时都会被分配一个数据结构,称为进程控制块( Process Control Block ,简称 PCB )。 PCB 中包含了很多重要的信息,供系统调度和进程本身执行使用,其中最重要的莫过于进程 ID process ID )了,进程 ID 也被称作进程标识符,是一个非负的整数,在 Linux 操作系统中唯一地标志一个进程,在我们最常使用的 I386 架构(即 PC 使用的架构)上,一个非负的整数的变化范围是 0-32767 ,这也是我们所有可能取到的进程 ID 。其实从进程 ID 的名字就可以看出,它就是进程的身份证号码,每个人的身份证号码都不会相同,每个进程的进程 ID 也不会相同。
    一个或多个进程可以合起来构成一个进程组( process group ),一个或多个进程组可以合起来构成一个会话( session )。这样我们就有了对进程进行批量操作的能力,比如通过向某个进程组发送信号来实现向该组中的每个进程发送信号。
    最后,让我们通过 ps 命令亲眼看一看自己的系统中目前有多少进程在运行:
     
    $ps -aux         (以下是在我的计算机上的运行结果,你的结果很可能与这不同。)
    
    USER       PID %CPU %MEM   VSZ RSS TTY      STAT START  TIME COMMAND
    
    root         1 0.1 0.4 1412 520 ?        S    May15   0:04 init [3]
    
    root         2 0.0 0.0     0    0 ?        SW   May15   0:00 [keventd]
    
    root         3 0.0 0.0     0    0 ?        SW   May15   0:00 [kapm-idled]
    
    root         4 0.0 0.0     0    0 ?        SWN May15   0:00 [ksoftirqd_CPU0]
    
    root         5 0.0 0.0     0    0 ?        SW   May15   0:00 [kswapd]
    
    root         6 0.0 0.0     0    0 ?        SW   May15   0:00 [kreclaimd]
    
    root         7 0.0 0.0     0    0 ?        SW   May15   0:00 [bdflush]
    
    root         8 0.0 0.0     0    0 ?        SW   May15   0:00 [kupdated]
    
    root         9 0.0 0.0     0    0 ?        SW< May15   0:00 [mdrecoveryd]
    
    root        13 0.0 0.0     0    0 ?        SW   May15   0:00 [kjournald]
    
    root       132 0.0 0.0     0    0 ?        SW   May15   0:00 [kjournald]
    
    root       673 0.0 0.4 1472 592 ?        S    May15   0:00 syslogd -m 0
    
    root       678 0.0 0.8 2084 1116 ?        S    May15   0:00 klogd -2
    
    rpc        698 0.0 0.4 1552 588 ?        S    May15   0:00 portmap
    
    rpcuser    726 0.0 0.6 1596 764 ?        S    May15   0:00 rpc.statd
    
    root       839 0.0 0.4 1396 524 ?        S    May15   0:00 /usr/sbin/apmd -p
    
    root       908 0.0 0.7 2264 1000 ?        S    May15   0:00 xinetd -stayalive
    
    root       948 0.0 1.5 5296 1984 ?        S    May15   0:00 sendmail: accepti
    
    root       967 0.0 0.3 1440 484 ?        S    May15   0:00 gpm -t ps/2 -m /d
    
    wnn        987 0.0 2.7 4732 3440 ?        S    May15   0:00 /usr/bin/cserver
    
    root      1005 0.0 0.5 1584 660 ?        S    May15   0:00 crond
    
    wnn       1025 0.0 1.9 3720 2488 ?        S    May15   0:00 /usr/bin/tserver
    
    xfs       1079 0.0 2.5 4592 3216 ?        S    May15   0:00 xfs -droppriv -da
    
    daemon    1115 0.0 0.4 1444 568 ?        S    May15   0:00 /usr/sbin/atd
    
    root      1130 0.0 0.3 1384 448 tty1     S    May15   0:00 /sbin/mingetty tt
    
    root      1131 0.0 0.3 1384 448 tty2     S    May15   0:00 /sbin/mingetty tt
    
    root      1132 0.0 0.3 1384 448 tty3     S    May15   0:00 /sbin/mingetty tt
    
    root      1133 0.0 0.3 1384 448 tty4     S    May15   0:00 /sbin/mingetty tt
    
    root      1134 0.0 0.3 1384 448 tty5     S    May15   0:00 /sbin/mingetty tt
    
    root      1135 0.0 0.3 1384 448 tty6     S    May15   0:00 /sbin/mingetty tt
    
    root      8769 0.0 0.6 1744 812 ?        S    00:08   0:00 in.telnetd: 192.1
    
    root      8770 0.0 0.9 2336 1184 pts/0    S    00:08   0:00 login -- lei
    
    lei       8771 0.1 0.9 2432 1264 pts/0    S    00:08   0:00 -bash
    
    lei       8809 0.0 0.6 2764 808 pts/0    R    00:09   0:00 ps -aux
     
    以上除标题外,每一行都代表一个进程。在各列中, PID 一列代表了各进程的进程 ID COMMAND 一列代表了进程的名称或在 Shell 中调用的命令行,对其他列的具体含义,我就不再作解释,有兴趣的读者可以去参考相关书籍。
     
    getpid
    2.4.4 版内核中, getpid 是第 20 号系统调用,其在 Linux 函数库中的原型是:
             #include<sys/types.h> /* 提供类型 pid_t 的定义 */
             #include<unistd.h> /* 提供函数的定义 */
    pid_t getpid(void);
     
    getpid 的作用很简单,就是返回当前进程的进程 ID ,请大家看以下的例子:
    /* getpid_test.c *
    /#include<unistd.h>
    main()
    {      
    printf("The current process ID is %d/n",getpid());
    }
     
    细心的读者可能注意到了,这个程序的定义里并没有包含头文件 sys/types.h ,这是因为我们在程序中没有用到 pid_t 类型, pid_t 类型即为进程 ID 的类型。事实上,在 i386 架构上(就是我们一般 PC 计算机的架构), pid_t 类型是和 int 类型完全兼容的,我们可以用处理整形数的方法去处理 pid_t 类型的数据,比如,用 "%d" 把它打印出来。
     
    编译并运行程序 getpid_test.c
     
    $gcc getpid_test.c -o getpid_test
    $./getpid_test
    The current process ID is 1980 (你自己的运行结果很可能与这个数字不一样,这是很正常的。)
     
    再运行一遍:
    $./getpid_test
    The current process ID is 1981
     
    正如我们所见,尽管是同一个应用程序,每一次运行的时候,所分配的进程标识符都不相同。
     
     
    fork
    2.4.4 版内核中, fork 是第 2 号系统调用,其在 Linux 函数库中的原型是:
             #include   <sys/types.h> /* 提供类型 pid_t 的定义 */
             #include<unistd.h> /* 提供函数的定义 */
             pid_t fork(void);
     
    只看 fork 的名字,可能难得有几个人可以猜到它是做什么用的。 fork 系统调用的作用是复制一个进程。当一个进程调用它,完成后就出现两个几乎一模一样的进程,我们也由此得到了一个新进程。据说 fork 的名字就是来源于这个与叉子的形状颇有几分相似的工作流程。
    Linux 中,创造新进程的方法只有一个,就是我们正在介绍的 fork 。其他一些库函数,如 system() ,看起来似乎它们也能创建新的进程,如果能看一下它们的源码就会明白,它们实际上也在内部调用了 fork 。包括我们在命令行下运行应用程序,新的进程也是由 shell 调用 fork 制造出来的。 fork 有一些很有意思的特征,下面就让我们通过一个小程序来对它有更多的了解。
     
    /* fork_test.c */
    #include<sys/types.h>
    #inlcude<unistd.h>
    main()
    {
             pid_t pid;           /* 此时仅有一个进程 */
             pid=fork();         /* 此时已经有两个进程在同时运行 */
             if(pid<0)
                       printf("error in fork!");
             else if(pid==0)
                       printf("I am the child process, my process ID is %d/n",getpid());
             else            printf("I am the parent process, my process ID is %d/n",getpid());
    }
    编译并运行:
    $gcc fork_test.c -o fork_test
    $./fork_test
    I am the parent process, my process ID is 1991
    I am the child process, my process ID is 1992
     
    看这个程序的时候,头脑中必须首先了解一个概念:在语句 pid=fork() 之前,只有一个进程在执行这段代码,但在这条语句之后,就变成两个进程在执行了,这两个进程的代码部分完全相同,将要执行的下一条语句都是 if(pid==0) ……。
    两个进程中,原先就存在的那个被称作“父进程”,新出现的那个被称作“子进程”。父子进程的区别除了进程标志符( process ID )不同外,变量 pid 的值也不相同, pid 存放的是 fork 的返回值。 fork 调用的一个奇妙之处就是它仅仅被调用一次,却能够返回两次,它可能有三种不同的返回值:
    在父进程中, fork 返回新创建子进程的进程 ID
    在子进程中, fork 返回 0
    如果出现错误, fork 返回一个负值;
    fork 出错可能有两种原因:
    1 )当前的进程数已经达到了系统规定的上限,这时 errno 的值被设置为 EAGAIN
    2 )系统内存不足,这时 errno 的值被设置为 ENOMEM 。(关于 errno 的意义,请参考本系列的第一篇文章。)
    fork 系统调用出错的可能性很小,而且如果出错,一般都为第一种错误。如果出现第二种错误,说明系统已经没有可分配的内存,正处于崩溃的边缘,这种情况对 Linux 来说是很罕见的。
    说到这里,聪明的读者可能已经完全看懂剩下的代码了,如果 pid 小于 0 ,说明出现了错误; pid==0 ,就说明 fork 返回了 0 ,也就说明当前进程是子进程,就去执行 printf("I am the child!") ,否则( else ),当前进程就是父进程,执行 printf("I am the parent!") 。完美主义者会觉得这很冗余,因为两个进程里都各有一条它们永远执行不到的语句。不必过于为此耿耿于怀,毕竟很多年以前, UNIX 的鼻祖们在当时内存小得无法想象的计算机上就是这样写程序的,以我们如今的“海量”内存,完全可以把这几个字节的顾虑抛到九霄云外。
    说到这里,可能有些读者还有疑问:如果 fork 后子进程和父进程几乎完全一样,而系统中产生新进程唯一的方法就是 fork ,那岂不是系统中所有的进程都要一模一样吗?那我们要执行新的应用程序时候怎么办呢?从对 Linux 系统的经验中,我们知道这种问题并不存在。至于采用了什么方法,我们把这个问题留到后面具体讨论。
     
    exit
    2.4.4 版内核中, exit 是第 1 号调用,其在 Linux 函数库中的原型是:
             #include<stdlib.h>
             void exit(int status);
     
    不像 fork 那么难理解,从 exit 的名字就能看出,这个系统调用是用来终止一个进程的。无论在程序中的什么位置,只要执行到 exit 系统调用,进程就会停止剩下的所有操作,清除包括 PCB 在内的各种数据结构,并终止本进程的运行。请看下面的程序:
     
    /* exit_test1.c */
    #include<stdlib.h>
    main()
    {
             printf("this process will exit!/n");
             exit(0);
             printf("never be displayed!/n");
    }
    编译后运行:
    $gcc exit_test1.c -o exit_test1$./exit_test1this process will exit!
     
    我们可以看到,程序并没有打印后面的 "never be displayed!/n" ,因为在此之前,在执行到 exit(0) 时,进程就已经终止了。
    exit 系统调用带有一个整数类型的参数 status ,我们可以利用这个参数传递进程结束时的状态,比如说,该进程是正常结束的,还是出现某种意外而结束的,一般来说, 0 表示没有意外的正常结束;其他的数值表示出现了错误,进程非正常结束。我们在实际编程时,可以用 wait 系统调用接收子进程的返回值,从而针对不同的情况进行不同的处理。关于 wait 的详细情况,我们将在以后的篇幅中进行介绍。
     
    exit _exit
    作为系统调用而言, _exit exit 是一对孪生兄弟,它们究竟相似到什么程度,我们可以从 Linux 的源码中找到答案:
    #define __NR__exit __NR_exit /* 摘自文件 include/asm-i386/unistd.h 334 */
     
    __NR_ ”是在 Linux 的源码中为每个系统调用加上的前缀,请注意第一个 exit 前有 2 条下划线,第二个 exit 前只有 1 条下划线。
    这时随便一个懂得 C 语言并且头脑清醒的人都会说, _exit exit 没有任何区别,但我们还要讲一下这两者之间的区别,这种区别主要体现在它们在函数库中的定义。 _exit Linux 函数库中的原型是:
             #include<unistd.h>
             void _exit(int status);
    exit 比较一下, exit() 函数定义在 stdlib.h 中,而 _exit() 定义在 unistd.h 中,从名字上看, stdlib.h 似乎比 unistd.h 高级一点,那么,它们之间到底有什么区别呢?让我们先来看流程图,通过下图,我们会对这两个系统调用的执行过程产生一个较为直观的认识。
     
    _exit() 函数的作用最为简单:直接使进程停止运行,清除其使用的内存空间,并销毁其在内核中的各种数据结构; exit() 函数则在这些基础上作了一些包装,在执行退出之前加了若干道工序,也是因为这个原因,有些人认为 exit 已经不能算是纯粹的系统调用。
    exit() 函数与 _exit() 函数最大的区别就在于 exit() 函数在调用 exit 系统调用之前要检查文件的打开情况,把文件缓冲区中的内容写回文件,就是图中的“清理 I/O 缓冲”一项。
    Linux 的标准函数库中,有一套称作“高级 I/O ”的函数,我们熟知的 printf() fopen() fread() fwrite() 都在此列,它们也被称作“缓冲 I/O buffered I/O )”,其特征是对应每一个打开的文件,在内存中都有一片缓冲区,每次读文件时,会多读出若干条记录,这样下次读文件时就可以直接从内存的缓冲区中读取,每次写文件的时候,也仅仅是写入内存中的缓冲区,等满足了一定的条件(达到一定数量,或遇到特定字符,如换行符 /n 和文件结束符 EOF ),再将缓冲区中的内容一次性写入文件,这样就大大增加了文件读写的速度,但也为我们编程带来了一点点麻烦。如果有一些数据,我们认为已经写入了文件,实际上因为没有满足特定的条件,它们还只是保存在缓冲区内,这时我们用 _exit() 函数直接将进程关闭,缓冲区中的数据就会丢失,反之,如果想保证数据的完整性,就一定要使用 exit() 函数。
    请看以下例程:
    /* exit2.c */
    #include<stdlib.h>
    main()
    {
             printf("output begin/n"); 
    printf("content in buffer");
             exit(0);
    }
    编译并运行:
    $gcc exit2.c -o exit2
    $./exit2
    output begin
    content in buffer
     
    /* _exit1.c *
    /#include<unistd.h>
    main()
    {
             printf("output begin/n");
             printf("content in buffer");
             _exit(0);
    }
    编译并运行:
    $gcc _exit1.c -o _exit1$./_exit1output begin
     
    Linux 中,标准输入和标准输出都是作为文件处理的,虽然是一类特殊的文件,但从程序员的角度来看,它们和硬盘上存储数据的普通文件并没有任何区别。与所有其他文件一样,它们在打开后也有自己的缓冲区。
    请读者结合前面的叙述,思考一下为什么这两个程序会得出不同的结果。相信如果您理解了我前面所讲的内容,会很容易的得出结论。
     
    1.7 背景
    在前面的文章中,我们已经了解了父进程和子进程的概念,并已经掌握了系统调用 exit 的用法,但可能很少有人意识到,在一个进程调用了 exit 之后,该进程并非马上就消失掉,而是留下一个称为僵尸进程( Zombie )的数据结构。在 Linux 进程的 5 种状态中,僵尸进程是非常特殊的一种,它已经放弃了几乎所有内存空间,没有任何可执行代码,也不能被调度,仅仅在进程列表中保留一个位置,记载该进程的退出状态等信息供其他进程收集,除此之外,僵尸进程不再占有任何内存空间。从这点来看,僵尸进程虽然有一个很酷的名字,但它的影响力远远抵不上那些真正的僵尸兄弟,真正的僵尸总能令人感到恐怖,而僵尸进程却除了留下一些供人凭吊的信息,对系统毫无作用。
    也许读者们还对这个新概念比较好奇,那就让我们来看一眼 Linux 里的僵尸进程究竟长什么样子。
    当一个进程已退出,但其父进程还没有调用系统调用 wait (稍后介绍)对其进行收集之前的这段时间里,它会一直保持僵尸状态,利用这个特点,我们来写一个简单的小程序:

    /* zombie.c */ #include <sys/types.h> #include <unistd.h> main() {          pid_t pid;                   pid=fork();          if(pid<0)        /* 如果出错 */                  printf("error occurred!/n");          else if(pid==0) /* 如果是子进程 */                  exit(0);          else             /* 如果是父进程 */                  sleep(60);       /* 休眠60秒,这段时间里,父进程什么也干不了 */                  wait(NULL);      /* 收集僵尸进程 */ }

    sleep 的作用是让进程休眠指定的秒数,在这 60 秒内,子进程已经退出,而父进程正忙着睡觉,不可能对它进行收集,这样,我们就能保持子进程 60 秒的僵尸状态。
    编译这个程序:

    $ cc zombie.c -o zombie

     
    后台运行程序,以使我们能够执行下一条命令

    $ ./zombie & [1] 1577

     
    列一下系统内的进程

    $ ps -ax          ... ...  1177 pts/0    S      0:00 -bash  1577 pts/0    S      0:00 ./zombie  1578 pts/0    Z      0:00 [zombie <defunct>]  1579 pts/0    R      0:00 ps -ax

    看到中间的 "Z" 了吗?那就是僵尸进程的标志,它表示 1578 号进程现在就是一个僵尸进程。
    我们已经学习了系统调用 exit ,它的作用是使进程退出,但也仅仅限于将一个正常的进程变成一个僵尸进程,并不能将其完全销毁。僵尸进程虽然对其他进程几乎没有什么影响,不占用 CPU 时间,消耗的内存也几乎可以忽略不计,但有它在那里呆着,还是让人觉得心里很不舒服。而且 Linux 系统中进程数目是有限制的,在一些特殊的情况下,如果存在太多的僵尸进程,也会影响到新进程的产生。那么,我们该如何来消灭这些僵尸进程呢?
    先来了解一下僵尸进程的来由,我们知道, Linux UNIX 总有着剪不断理还乱的亲缘关系,僵尸进程的概念也是从 UNIX 上继承来的,而 UNIX 的先驱们设计这个东西并非是因为闲来无聊想烦烦其他的程序员。僵尸进程中保存着很多对程序员和系统管理员非常重要的信息,首先,这个进程是怎么死亡的?是正常退出呢,还是出现了错误,还是被其它进程强迫退出的?其次,这个进程占用的总系统 CPU 时间和总用户 CPU 时间分别是多少?发生页错误的数目和收到信号的数目。这些信息都被存储在僵尸进程中,试想如果没有僵尸进程,进程一退出,所有与之相关的信息都立刻归于无形,而此时程序员或系统管理员需要用到,就只好干瞪眼了。
    那么,我们如何收集这些信息,并终结这些僵尸进程呢?就要靠我们下面要讲到的 waitpid 调用和 wait 调用。这两者的作用都是收集僵尸进程留下的信息,同时使这个进程彻底消失。下面就对这两个调用分别作详细介绍。
    1.8.1 简介
    wait 的函数原型是:

                     #include <sys/types.h> /* 提供类型pid_t的定义 */          #include <sys/wait.h>          pid_t wait(int *status)         

     
    进程一旦调用了 wait ,就立即阻塞自己,由 wait 自动分析是否当前进程的某个子进程已经退出,如果让它找到了这样一个已经变成僵尸的子进程, wait 就会收集这个子进程的信息,并把它彻底销毁后返回;如果没有找到这样一个子进程, wait 就会一直阻塞在这里,直到有一个出现为止。
    参数 status 用来保存被收集进程退出时的一些状态,它是一个指向 int 类型的指针。但如果我们对这个子进程是如何死掉的毫不在意,只想把这个僵尸进程消灭掉,(事实上绝大多数情况下,我们都会这样想),我们就可以设定这个参数为 NULL ,就象下面这样:

                     pid = wait(NULL);         

     
    如果成功, wait 会返回被收集的子进程的进程 ID ,如果调用进程没有子进程,调用就会失败,此时 wait 返回 -1 ,同时 errno 被置为 ECHILD
    1.8.2 实战
    下面就让我们用一个例子来实战应用一下 wait 调用,程序中用到了系统调用 fork ,如果你对此不大熟悉或已经忘记了,请参考上一篇文章《进程管理相关的系统调用(一)》。

    /* wait1.c */ #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <stdlib.h> main() {          pid_t pc,pr;          pc=fork();          if(pc<0)                  /* 如果出错 */                  printf("error ocurred!/n");          else if(pc==0){           /* 如果是子进程 */                  printf("This is child process with pid of %d/n",getpid());                  sleep(10);       /* 睡眠10秒钟 */          }          else{                     /* 如果是父进程 */                  pr=wait(NULL);   /* 在这里等待 */                  printf("I catched a child process with pid of %d/n"),pr);          }                         exit(0); }

     
    编译并运行 :

    $ cc wait1.c -o wait1 $ ./wait1 This is child process with pid of 1508 I catched a child process with pid of 1508

     
    可以明显注意到,在第 2 行结果打印出来前有 10 秒钟的等待时间,这就是我们设定的让子进程睡眠的时间,只有子进程从睡眠中苏醒过来,它才能正常退出,也就才能被父进程捕捉到。其实这里我们不管设定子进程睡眠的时间有多长,父进程都会一直等待下去,读者如果有兴趣的话,可以试着自己修改一下这个数值,看看会出现怎样的结果。
    1.8.3 参数 status
    如果参数 status 的值不是 NULL wait 就会把子进程退出时的状态取出并存入其中,这是一个整数值( int ),指出了子进程是正常退出还是被非正常结束的(一个进程也可以被其他进程用信号结束,我们将在以后的文章中介绍),以及正常结束时的返回值,或被哪一个信号结束的等信息。由于这些信息被存放在一个整数的不同二进制位中,所以用常规的方法读取会非常麻烦,人们就设计了一套专门的宏( macro )来完成这项工作,下面我们来学习一下其中最常用的两个:
    1 WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的,如果是,它会返回一个非零值。
    (请注意,虽然名字一样,这里的参数 status 并不同于 wait 唯一的参数 -- 指向整数的指针 status ,而是那个指针所指向的整数,切记不要搞混了。)
    2 WEXITSTATUS(status) WIFEXITED 返回非零值时,我们可以用这个宏来提取子进程的返回值,如果子进程调用 exit(5) 退出, WEXITSTATUS(status) 就会返回 5 ;如果子进程调用 exit(7) WEXITSTATUS(status) 就会返回 7 。请注意,如果进程不是正常退出的,也就是说, WIFEXITED 返回 0 ,这个值就毫无意义。
    下面通过例子来实战一下我们刚刚学到的内容:

    /* wait2.c */ #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> main() {          int status;          pid_t pc,pr;          pc=fork();          if(pc<0) /* 如果出错 */                  printf("error ocurred!/n");          else if(pc==0){ /* 子进程 */                  printf("This is child process with pid of %d./n",getpid());                  exit(3); /* 子进程返回3 */          }          else{            /* 父进程 */                  pr=wait(&status);                  if(WIFEXITED(status)){    /* 如果WIFEXITED返回非零值 */                           printf("the child process %d exit normally./n",pr);                           printf("the return code is %d./n",WEXITSTATUS(status));                  }else                     /* 如果WIFEXITED返回零 */                           printf("the child process %d exit abnormally./n",pr);          } }

     
    编译并运行 :

    $ cc wait2.c -o wait2 $ ./wait2 This is child process with pid of 1538. the child process 1538 exit normally. the return code is 3.

     
    父进程准确捕捉到了子进程的返回值 3 ,并把它打印了出来。
    当然,处理进程退出状态的宏并不止这两个,但它们当中的绝大部分在平时的编程中很少用到,就也不在这里浪费篇幅介绍了,有兴趣的读者可以自己参阅 Linux man pages 去了解它们的用法。
    1.8.4 进程同步
    有时候,父进程要求子进程的运算结果进行下一步的运算,或者子进程的功能是为父进程提供了下一步执行的先决条件(如:子进程建立文件,而父进程写入数据),此时父进程就必须在某一个位置停下来,等待子进程运行结束,而如果父进程不等待而直接执行下去的话,可以想见,会出现极大的混乱。这种情况称为进程之间的同步,更准确地说,这是进程同步的一种特例。进程同步就是要协调好 2 个以上的进程,使之以安排好地次序依次执行。解决进程同步问题有更通用的方法,我们将在以后介绍,但对于我们假设的这种情况,则完全可以用 wait 系统调用简单的予以解决。请看下面这段程序:

    #include <sys/types.h> #include <sys/wait.h> main() {          pid_t pc, pr;          int status;                   pc=fork();                   if(pc<0)                  printf("Error occured on forking./n");          else if(pc==0){                  /* 子进程的工作 */                  exit(0);          }else{                  /* 父进程的工作 */                  pr=wait(&status);                  /* 利用子进程的结果 */          } }

     
    这段程序只是个例子,不能真正拿来执行,但它却说明了一些问题,首先,当 fork 调用成功后,父子进程各做各的事情,但当父进程的工作告一段落,需要用到子进程的结果时,它就停下来调用 wait ,一直等到子进程运行结束,然后利用子进程的结果继续执行,这样就圆满地解决了我们提出的进程同步问题。
    1.9.1 简介
    waitpid 系统调用在 Linux 函数库中的原型是:

                     #include <sys/types.h> /* 提供类型pid_t的定义 */          #include <sys/wait.h>          pid_t waitpid(pid_t pid,int *status,int options)         

     
    从本质上讲,系统调用 waitpid wait 的作用是完全相同的,但 waitpid 多出了两个可由用户控制的参数 pid options ,从而为我们编程提供了另一种更灵活的方式。下面我们就来详细介绍一下这两个参数:
    pid
    从参数的名字 pid 和类型 pid_t 中就可以看出,这里需要的是一个进程 ID 。但当 pid 取不同的值时,在这里有不同的意义。
    1. pid>0 时,只等待进程 ID 等于 pid 的子进程,不管其它已经有多少子进程运行结束退出了,只要指定的子进程还没有结束, waitpid 就会一直等下去。
    2. pid=-1 时,等待任何一个子进程退出,没有任何限制,此时 waitpid wait 的作用一模一样。
    3. pid=0 时,等待同一个进程组中的任何子进程,如果子进程已经加入了别的进程组, waitpid 不会对它做任何理睬。
    4. pid<-1 时,等待一个指定进程组中的任何子进程,这个进程组的 ID 等于 pid 的绝对值。
    options 提供了一些额外的选项来控制 waitpid ,目前在 Linux 中只支持 WNOHANG WUNTRACED 两个选项,这是两个常数,可以用 "|" 运算符把它们连接起来使用,比如:

    ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);

     
    如果我们不想使用它们,也可以把 options 设为 0 ,如:

    ret=waitpid(-1,NULL,0);

     
    如果使用了 WNOHANG 参数调用 waitpid ,即使没有子进程退出,它也会立即返回,不会像 wait 那样永远等下去。
    WUNTRACED 参数,由于涉及到一些跟踪调试方面的知识,加之极少用到,这里就不多费笔墨了,有兴趣的读者可以自行查阅相关材料。
    看到这里,聪明的读者可能已经看出端倪了 --wait 不就是经过包装的 waitpid 吗?没错,察看 < 内核源码目录 >/include/unistd.h 文件 349-352 行就会发现以下程序段:

    static inline pid_t wait(int * wait_stat) {          return waitpid(-1,wait_stat,0); }

     
    1.9.2 返回值和错误
    waitpid 的返回值比 wait 稍微复杂一些,一共有 3 种情况:
    1. 当正常返回的时候, waitpid 返回收集到的子进程的进程 ID
    2. 如果设置了选项 WNOHANG ,而调用中 waitpid 发现没有已退出的子进程可收集,则返回 0
    3. 如果调用中出错,则返回 -1 ,这时 errno 会被设置成相应的值以指示错误所在;
    pid 所指示的子进程不存在,或此进程存在,但不是调用进程的子进程, waitpid 就会出错返回,这时 errno 被设置为 ECHILD

    /* waitpid.c */ #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> main() {          pid_t pc, pr;                           pc=fork();          if(pc<0)         /* 如果fork出错 */                  printf("Error occured on forking./n");          else if(pc==0){           /* 如果是子进程 */                  sleep(10);       /* 睡眠10秒 */                  exit(0);          }          /* 如果是父进程 */          do{                  pr=waitpid(pc, NULL, WNOHANG);     /* 使用了WNOHANG参数,waitpid不会在这里等待 */                  if(pr==0){                         /* 如果没有收集到子进程 */                           printf("No child exited/n");                           sleep(1);                  }          }while(pr==0);                              /* 没有收集到子进程,就回去继续尝试 */          if(pr==pc)                  printf("successfully get child %d/n", pr);          else                  printf("some error occured/n"); }

     
    编译并运行:

    $ cc waitpid.c -o waitpid $ ./waitpid No child exited No child exited No child exited No child exited No child exited No child exited No child exited No child exited No child exited No child exited successfully get child 1526

     
    父进程经过 10 次失败的尝试之后,终于收集到了退出的子进程。
    因为这只是一个例子程序,不便写得太复杂,所以我们就让父进程和子进程分别睡眠了 10 秒钟和 1 秒钟,代表它们分别作了 10 秒钟和 1 秒钟的工作。父子进程都有工作要做,父进程利用工作的简短间歇察看子进程的是否退出,如退出就收集它。
     

     
    也许有不少读者从本系列文章一推出就开始读,一直到这里还有一个很大的疑惑:既然所有新进程都是由 fork 产生的,而且由 fork 产生的子进程和父进程几乎完全一样,那岂不是意味着系统中所有的进程都应该一模一样了吗?而且,就我们的常识来说,当我们执行一个程序的时候,新产生的进程的内容应就是程序的内容才对。是我们理解错了吗?显然不是,要解决这些疑惑,就必须提到我们下面要介绍的 exec 系统调用。
    1.10.1 简介
    说是 exec 系统调用,实际上在 Linux 中,并不存在一个 exec() 的函数形式, exec 指的是一组函数,一共有 6 个,分别是:

    #include <unistd.h> int execl(const char *path, const char *arg, ...); int execlp(const char *file, const char *arg, ...); int execle(const char *path, const char *arg, ..., char *const envp[]); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]); int execve(const char *path, char *const argv[], char *const envp[]);

     
    其中只有 execve 是真正意义上的系统调用,其它都是在此基础上经过包装的库函数。
    exec 函数族的作用是根据指定的文件名找到可执行文件,并用它来取代调用进程的内容,换句话说,就是在调用进程内部执行一个可执行文件。这里的可执行文件既可以是二进制文件,也可以是任何 Linux 下可执行的脚本文件。
    与一般情况不同, exec 函数族的函数执行成功后不会返回,因为调用进程的实体,包括代码段,数据段和堆栈等都已经被新的内容取代,只留下进程 ID 等一些表面上的信息仍保持原样,颇有些神似 " 三十六计 " 中的 " 金蝉脱壳 " 。看上去还是旧的躯壳,却已经注入了新的灵魂。只有调用失败了,它们才会返回一个 -1 ,从原程序的调用点接着往下执行。
    现在我们应该明白了, Linux 下是如何执行新程序的,每当有进程认为自己不能为系统和拥护做出任何贡献了,他就可以发挥最后一点余热,调用任何一个 exec ,让自己以新的面貌重生;或者,更普遍的情况是,如果一个进程想执行另一个程序,它就可以 fork 出一个新进程,然后调用任何一个 exec ,这样看起来就好像通过执行应用程序而产生了一个新进程一样。
    事实上第二种情况被应用得如此普遍,以至于 Linux 专门为其作了优化,我们已经知道, fork 会将调用进程的所有内容原封不动的拷贝到新产生的子进程中去,这些拷贝的动作很消耗时间,而如果 fork 完之后我们马上就调用 exec ,这些辛辛苦苦拷贝来的东西又会被立刻抹掉,这看起来非常不划算,于是人们设计了一种 " 写时拷贝( copy-on-write " 技术,使得 fork 结束后并不立刻复制父进程的内容,而是到了真正实用的时候才复制,这样如果下一条语句是 exec ,它就不会白白作无用功了,也就提高了效率。
    1.10.2 稍稍深入
    上面 6 条函数看起来似乎很复杂,但实际上无论是作用还是用法都非常相似,只有很微小的差别。在学习它们之前,先来了解一下我们习以为常的 main 函数。
    下面这个 main 函数的形式可能有些出乎我们的意料:

    int main(int argc, char *argv[], char *envp[])

     
    它可能与绝大多数教科书上描述的都不一样,但实际上,这才是 main 函数真正完整的形式。
    参数 argc 指出了运行该程序时命令行参数的个数,数组 argv 存放了所有的命令行参数,数组 envp 存放了所有的环境变量。环境变量指的是一组值,从用户登录后就一直存在,很多应用程序需要依靠它来确定系统的一些细节,我们最常见的环境变量是 PATH ,它指出了应到哪里去搜索应用程序,如 /bin HOME 也是比较常见的环境变量,它指出了我们在系统中的个人目录。环境变量一般以字符串 "XXX=xxx" 的形式存在, XXX 表示变量名, xxx 表示变量的值。
    值得一提的是, argv 数组和 envp 数组存放的都是指向字符串的指针,这两个数组都以一个 NULL 元素表示数组的结尾。
    我们可以通过以下这个程序来观看传到 argc argv envp 里的都是什么东西:

    /* main.c */ int main(int argc, char *argv[], char *envp[]) {          printf("/n### ARGC ###/n%d/n", argc);          printf("/n### ARGV ###/n");          while(*argv)                  printf("%s/n", *(argv++));          printf("/n### ENVP ###/n");          while(*envp)                  printf("%s/n", *(envp++));          return 0; }

     
    编译它:

    $ cc main.c -o main

     
    运行时,我们故意加几个没有任何作用的命令行参数:

    $ ./main -xx 000 ### ARGC ### 3 ### ARGV ### ./main -xx 000 ### ENVP ### PWD=/home/lei REMOTEHOST=dt.laser.com HOSTNAME=localhost.localdomain QTDIR=/usr/lib/qt-2.3.1 LESSOPEN=|/usr/bin/lesspipe.sh %s KDEDIR=/usr USER=lei LS_COLORS= MACHTYPE=i386-redhat-linux-gnu MAIL=/var/spool/mail/lei INPUTRC=/etc/inputrc LANG=en_US LOGNAME=lei SHLVL=1 SHELL=/bin/bash HOSTTYPE=i386 OSTYPE=linux-gnu HISTSIZE=1000 TERM=ansi HOME=/home/lei PATH=/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/home/lei/bin _=./main

     
    我们看到,程序将 "./main" 作为第 1 个命令行参数,所以我们一共有 3 个命令行参数。这可能与大家平时习惯的说法有些不同,小心不要搞错了。
    现在回过头来看一下 exec 函数族,先把注意力集中在 execve 上:

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

     
    对比一下 main 函数的完整形式,看出问题了吗?是的,这两个函数里的 argv envp 是完全一一对应的关系。 execve 1 个参数 path 是被执行应用程序的完整路径,第 2 个参数 argv 就是传给被执行应用程序的命令行参数,第 3 个参数 envp 是传给被执行应用程序的环境变量。
    留心看一下这 6 个函数还可以发现,前 3 个函数都是以 execl 开头的,后 3 个都是以 execv 开头的,它们的区别在于, execv 开头的函数是以 "char *argv[]" 这样的形式传递命令行参数,而 execl 开头的函数采用了我们更容易习惯的方式,把参数一个一个列出来,然后以一个 NULL 表示结束。这里的 NULL 的作用和 argv 数组里的 NULL 作用是一样的。
    在全部 6 个函数中,只有 execle execve 使用了 char *envp[] 传递环境变量,其它的 4 个函数都没有这个参数,这并不意味着它们不传递环境变量,这 4 个函数将把默认的环境变量不做任何修改地传给被执行的应用程序。而 execle execve 会用指定的环境变量去替代默认的那些。
    还有 2 个以 p 结尾的函数 execlp execvp ,咋看起来,它们和 execl execv 的差别很小,事实也确是如此,除 execlp execvp 之外的 4 个函数都要求,它们的第 1 个参数 path 必须是一个完整的路径,如 "/bin/ls" ;而 execlp execvp 的第 1 个参数 file 可以简单到仅仅是一个文件名,如 "ls" ,这两个函数可以自动到环境变量 PATH 制定的目录里去寻找。
    1.10.3 实战
    知识介绍得差不多了,接下来我们看看实际的应用:

    /* exec.c */ #include <unistd.h> main() {          char *envp[]={"PATH=/tmp",                           "USER=lei",                           "STATUS=testing",                           NULL};          char *argv_execv[]={"echo", "excuted by execv",     NULL};          char *argv_execvp[]={"echo", "executed by execvp", NULL};          char *argv_execve[]={"env", NULL};          if(fork()==0)                  if(execl("/bin/echo", "echo", "executed by execl", NULL)<0)                           perror("Err on execl");          if(fork()==0)                  if(execlp("echo", "echo", "executed by execlp", NULL)<0)                           perror("Err on execlp");          if(fork()==0)                  if(execle("/usr/bin/env", "env", NULL, envp)<0)                           perror("Err on execle");          if(fork()==0)                  if(execv("/bin/echo", argv_execv)<0)                           perror("Err on execv");          if(fork()==0)                  if(execvp("echo", argv_execvp)<0)                           perror("Err on execvp");          if(fork()==0)                  if(execve("/usr/bin/env", argv_execve, envp)<0)                           perror("Err on execve"); }

     
    程序里调用了 2 Linux 常用的系统命令, echo env echo 会把后面跟的命令行参数原封不动的打印出来, env 用来列出所有环境变量。
    由于各个子进程执行的顺序无法控制,所以有可能出现一个比较混乱的输出 -- 各子进程打印的结果交杂在一起,而不是严格按照程序中列出的次序。
    编译并运行:

    $ cc exec.c -o exec $ ./exec executed by execl PATH=/tmp USER=lei STATUS=testing executed by execlp excuted by execv executed by execvp PATH=/tmp USER=lei STATUS=testing

     
    果然不出所料, execle 输出的结果跑到了 execlp 前面。
    大家在平时的编程中,如果用到了 exec 函数族,一定记得要加错误判断语句。因为与其他系统调用比起来, exec 很容易受伤,被执行文件的位置,权限等很多因素都能导致该调用的失败。最常见的错误是:
    1. 找不到文件或路径,此时 errno 被设置为 ENOENT
    2. 数组 argv envp 忘记用 NULL 结束,此时 errno 被设置为 EFAULT
    3. 没有对要执行文件的运行权限,此时 errno 被设置为 EACCES
     
    1.11 进程的一生
    下面就让我用一些形象的比喻,来对进程短暂的一生作一个小小的总结:
    随着一句 fork ,一个新进程呱呱落地,但它这时只是老进程的一个克隆。
    然后随着 exec ,新进程脱胎换骨,离家独立,开始了为人民服务的职业生涯。
    人有生老病死,进程也一样,它可以是自然死亡,即运行到 main 函数的最后一个 "}" ,从容地离我们而去;也可以是自杀,自杀有 2 种方式,一种是调用 exit 函数,一种是在 main 函数内使用 return ,无论哪一种方式,它都可以留下遗书,放在返回值里保留下来;它还甚至能可被谋杀,被其它进程通过另外一些方式结束他的生命。
    进程死掉以后,会留下一具僵尸, wait waitpid 充当了殓尸工,把僵尸推去火化,使其最终归于无形。
    这就是进程完整的一生。
    1.12 小结
    本文重点介绍了系统调用 wait waitpid exec 函数族,对与进程管理相关的系统调用的介绍就在这里告一段落,在下一篇文章,也是与进程管理相关的系统调用的最后一篇文章中,我们会通过两个很酷的实际例子,来重温一下最近学过的知识。
    1.13 Shell
    Linux 不是太陌生的读者都应该对 Shell 有一定的了解,就是这个程序在我们登陆后自动执行,打印出一个 $ 符号,然后等待我们输入命令。 Linux 下最常用的 Shell 应用程序是 Bash ,绝大部分 Linux 发行版默认安装的都是它。下面我们也来亲手编写一个 Shell 程序,这个 Shell 远远不如 Bash 复杂,但也能满足我们一般的使用,下面,我们就开始。
    首先,给这个 Shell 取一个名字,不妨就叫做 Mini Shell
    Linux 系统的命令分为内部命令和外部命令两种,内部命令由 Shell 程序实现,如 cd echo 等, Linux 的内部命令数量有限,而且绝大部分都很少用到。而每一个 Linux 外部命令都是一个单独的应用程序,我们非常熟悉的 ls cp 等绝大多数命令都是外部命令,这些命令都以可执行文件的形式存在,绝大部分放在目录 /bin /sbin 中。这样一来,我们编程的难度就可以大大下降了,我们只需要实现很有限的内部命令,对于其它的输入,统统当作应用程序来执行即可。
    为了简单明了起见, Mini Shell 只实现了 2 个内部命令: 1 cd 用于切换目录,和我们熟悉的命令 cd 类似,除了没有那么多的附加功能。 2 quit 用于退出 Mini Shell
    下面是程序清单:

    1:       /* mshell.c */ 2:       #include <sys/types.h> 1:       #include <unistd.h> 3:       #include <sys/wait.h> 4:       #include <string.h> 5:       #include <errno.h> 6:       #include <stdio.h> 7: 9:       void do_cd(char *argv[]); 10:      void execute_new(char *argv[]); 11: 12:      main() 13:      { 14:              char *cmd=(void *)malloc(256*sizeof(char)); 15:              char *cmd_arg[10]; 16:              int cmdlen,i,j,tag; 17:      18:              do{ 19:                       /* 初始化cmd */ 20:                       for(i=0;i<255;i++) cmd[i]='/0'; 21:      22:                       printf("-=Mini Shell=-*| "); 23:                       fgets(cmd,256,stdin); 24:      25:                       cmdlen=strlen(cmd); 26:                       cmdlen--; 27:                       cmd[cmdlen]='/0'; 28:      29 :                      /* 把命令行分解为指针数组cmd_arg */ 30 :                      for(i=0;i<10;i++) cmd_arg[i]=NULL; 31 :                      i=0; j=0; tag=0; 32 :                      while(i<cmdlen && j<10){ 33 :                               if(cmd[i]==' '){ 34 :                                        cmd[i]='/0'; 35 :                                        tag=0; 36 :                               }else{ 37 :                                        if(tag==0) 38 :                                                cmd_arg[j++]=cmd+i; 39 :                                        tag=1; 40 :                               } 41 :                               i++; 42 :                      } 43 :                      44 :                      /* 如果参数超过10个,就打印错误,并忽略当前输入 */ 45 :                      if(j>=10 && i<cmdlen){ 46 :                               printf("TOO MANY ARGUMENTS/n"); 47 :                               continue; 48 :                      } 49 :                      50 :                      /* 命令quit:退出Mini Shell */ 51 :                      if(strcmp(cmd_arg[0],"quit")==0) 52 :                               break; 53 :     54 :                      /* 命令cd */ 55 :                      if(strcmp(cmd_arg[0],"cd")==0){ 56 :                               do_cd(cmd_arg); 57 :                               continue; 58 :                      } 59 :                      60 :                      /* 外部命令或应用程序 */ 61 :                      execute_new(cmd_arg); 62 :              }while(1); 63 :     } 64 :     65 :     /* 实现cd的功能 */ 66 :     void do_cd(char *argv[]) 67 :     { 68 :              if(argv[1]!=NULL){ 69 :                      if(chdir(argv[1])<0) 70 :                               switch(errno){ 71 :                               case ENOENT: 72 :                                       printf("DIRECTORY NOT FOUND/n"); 73 :                                        break; 74 :                               case ENOTDIR: 75 :                                        printf("NOT A DIRECTORY NAME/n"); 76 :                                        break; 77 :                               case EACCES: 78 :                                        printf("YOU DO NOT HAVE RIGHT TO ACCESS/n"); 79 :                                        break; 80 :                               default: 81 :                                        printf("SOME ERROR HAPPENED IN CHDIR/n"); 82 :                               } 83 :              } 84 :     85 :     } 86 :     87 :     /* 执行外部命令或应用程序 */ 88 :     void execute_new(char *argv[]) 89 :     { 90 :              pid_t pid; 91 :     92 :              pid=fork(); 93 :              if(pid<0){ 94 :                      printf("SOME ERROR HAPPENED IN FORK/n"); 95 :                      exit(2); 96 :              }else if(pid==0){ 97 :                      if(execvp(argv[0],argv)<0) 98 :                               switch(errno){ 99 :                               case ENOENT: 100 :                                       printf("COMMAND OR FILENAME NOT FOUND/n"); 101 :                                       break; 102 :                              case EACCES: 103 :                                       printf("YOU DO NOT HAVE RIGHT TO ACCESS/n"); 104 :                                       break; 105 :                            default: 106 :                                    printf("SOME ERROR HAPPENED IN EXEC/n"); 107 :                              } 108 :                     exit(3); 109 :             }else 110 :                     wait(NULL); 111 :    }       

     
    这个程序稍稍有点长,我们来对它作一下详细的解释:
    函数 main
    14 行:定义字符串 cmd ,用于接收用户输入的命令行。 15 行:定义指针数组 cmd_arg ,它的形式和作用都与我们熟悉的 char *argv[] 一样。
    从以上 2 个定义可以看出 Mini Shell 对命令输入的 2 个限制:首先,用户输入的命令行必须在 255 个字符之内(除去字符串结束标志 '/0' );其次,命令行的参数个数不得超过 10 个(包括命令本身在内)。
    18 行:进入一个 do-while 循环,这个循环是本程序的主体部分,基本思想是 " 等待输入命令 -- 处理已输入命令 -- 等待输入命令 "
    22 行:打印输入提示信息。在 Mini Shell 中,你可以随意定自己喜欢的命令输入提示信息,本程序中使用了 "-=Mini Shell=-*| " ,是不是有点像一个 CS 高手?如果不喜欢,你可以用任意的字符替换它。
    23 行:接收用户输入。
    25-27 行: fgets 接受输入时,会将输入字符串时末尾的换行符( "/n" )一起接受,这是我们不需要的,所以要把它去掉。本程序中简单的用字符串结束标志 '/0' 覆盖了字符串 cmd 的最后一个字符来实现这个目的。
    30 行:初始化指针数组 cmd_arg
    32-42 行:对输入进行分析,将 cmd 中参数间的空格用 '/0' 填充,并把各参数的起始地址分别赋与 cmd_arg 数组。这样就把 cmd 分解成了 cmd_arg ,但分解后的各命令参数仍然使用着 cmd 的内存空间,所以在命令执行结束前不宜对 cmd 另外赋值。
    45 行:如果还未分析到输入字符串的末尾( i<cmdlen ),而分析出的参数已经达到或超过了 10 个( j>=10 ),就认为输入的命令行超出了 10 个参数的限制,打印错误并重新接收命令。
    51-52 行:内部命令 quit :字符串 cmd_arg[0] 就是命令本身,如果命令是 quit ,则退出循环,也就等于退出该程序。
    55-58 行:内部命令 cd :调用函数 do_cd() 完成 cd 命令的动作。
    61 行:对于其它的外部命令和应用程序,调用函数 execute_new() 执行。
    函数 do_cd
    68 行:仅仅考虑紧跟在命令后面的参数 argv[1] ,而不再考虑其它的参数。如果这个参数存在,就把它作为要转换的目录。
    69 行:调用系统调用 chdir 切换当前目录,参见附录 1
    70-82 行:对 chdir 可能出现的错误进行处理。
    函数 execute_new
    92 行:调用系统调用 fork 产生新的子进程。
    93 行:如果返回负值,说明 fork 调用出现错误。
    96 行:如果返回 0 ,说明当前进程是子进程。
    97 行:调用 execvp 执行新的应用程序,并检测调用是否出错(返回负值)。这里使用 execvp 的原因是它可以自动在各默认目录里寻找目标应用程序的位置,而不必我们自己编程实现。
    98-107 行:对 execvp 可能出现的错误进程处理。
    108 行:如果 execvp 的执行出现错误,子进程在这里终止。表面上看起来,这个 exit 是接着 97 行的错误判断的下一行语句,而非 if 语句的一部分,似乎无论调用 execvp 成功与否都会接着执行 exit 。但事实上,如果 execvp 调用成功的话,这个进程将会被新的程序代码填充,因而根本不可能执行到这一行。反之,如果执行到了这一行,说明前面的 execvp 调用一定出现了错误。这样的效果和 exit 被包含在 if 语句中的效果是完全一样的。
    109 行:如果 fork 返回其它值,说明当前进程是父进程。
    110 行:调用系统调用 wait wait 在这里有两个作用:
    1. 使父进程在此暂停,等待子进程执行完毕。这样,就可以等子进程的所有信息全部输出完毕后才打印命令提示符,等待下一条命令的输入,从而避免了命令提示符和应用程序输出混杂在一起的现象。
    2. 收集子进程退出后留下的僵尸进程。可能有读者一直对这个问题存有疑问 --" 我们编程生成的子进程由我们自己设计的父进程负责收集,但我们手动执行的这个父进程由谁收集呢? " 现在大家应该明白了,我们从命令行执行的所有进程最后都是由 shell 收集的。
    关于 Mini Shell 的编译和运行,这里就不再敷述了,有兴趣的读者可以自行动手实验,或者对这个程序进行改进,使之更接近甚至超过我们正使用的 Bash
    1.14 daemon 进程
    1.14.1 了解 daemon 进程
    这又是一个有趣的概念, daemon 在英语中是 " 精灵 " 的意思,就像我们经常在迪斯尼动画里见到的那些,有些会飞,有些不会,经常围着动画片的主人公转来转去,啰里啰唆地提一些忠告,时不时倒霉地撞在柱子上,有时候还会想出一些小小的花招,把主人公从敌人手中救出来,正因如此, daemon 有时也被译作 " 守护神 " 。所以, daemon 进程在国内也有两种译法,有些人译作 " 精灵进程 " ,有些人译作 " 守护进程 " ,这两种称呼的出现频率都很高。
    与真正的 daemon 相似, daemon 进程也习惯于把自己隐藏在人们的视线之外,默默为系统做出贡献,有时人们也把它们称作 " 后台服务进程 " daemon 进程的寿命很长,一般来说,从它们一被执行开始,直到整个系统关闭,它们才会退出。几乎所有的服务器程序,包括我们熟知的 Apache wu -FTP ,都用 daemon 进程的形式实现。很多 Linux 下常见的命令如 inetd ftpd ,末尾的字母 d 就是指 daemon
    为什么一定要使用 daemon 进程呢? Linux 中每一个系统与用户进行交流的界面称为终端( terminal ),每一个从此终端开始运行的进程都会依附于这个终端,这个终端就称为这些进程的控制终端( Controlling terminal ),当控制终端被关闭时,相应的进程都会被自动关闭。关于这点,读者可以用 X-Window 中的 XTerm 试验一下,(每一个 XTerm 就是一个打开的终端,)我们可以通过键入命令启动应用程序,比如:
    $netscape
    然后我们关闭 XTerm 窗口,刚刚启动的 netscape 窗口也会随之一同突然蒸发。但是 daemon 进程却能够突破这种限制,即使对应的终端关闭,它也能在系统中长久地存在下去,如果我们想让某个进程长命百岁,不因为用户或终端或其他的变化而受到影响,就必须把这个进程变成一个 daemon 进程。
    1.14.2 daemon 进程的编程规则
    如果想把自己的进程变成 daemon 进程,我们必须严格按照以下步骤进行:
    1. 调用 fork 产生一个子进程,同时父进程退出。我们所有后续工作都在子进程中完成。这样做我们可以:
    1.     如果我们是从命令行执行的该程序,这可以造成程序执行完毕的假象, shell 会回去等待下一条命令;
    2.     刚刚通过 fork 产生的新进程一定不会是一个进程组的组长,这为第 2 步的执行提供了前提保障。
    这样做还会出现一种很有趣的现象:由于父进程已经先于子进程退出,会造成子进程没有父进程,变成一个孤儿进程( orphan )。每当系统发现一个孤儿进程,就会自动由 1 号进程收养它,这样,原先的子进程就会变成 1 号进程的子进程。
    2. 调用 setsid 系统调用。这是整个过程中最重要的一步。 setsid 的介绍见附录 2 ,它的作用是创建一个新的会话( session ),并自任该会话的组长( session leader )。如果调用进程是一个进程组的组长,调用就会失败,但这已经在第 1 步得到了保证。调用 setsid 3 个作用:
    1.     让进程摆脱原会话的控制;
    2.     让进程摆脱原进程组的控制;
    3.     让进程摆脱原控制终端的控制;
    总之,就是让调用进程完全独立出来,脱离所有其他进程的控制。
    3. 把当前工作目录切换到根目录。如果我们是在一个临时加载的文件系统上执行这个进程的,比如: /mnt/floppy/ ,该进程的当前工作目录就会是 /mnt/floppy/ 。在整个进程运行期间该文件系统都无法被卸下( umount ),而无论我们是否在使用这个文件系统,这会给我们带来很多不便。解决的方法是使用 chdir 系统调用把当前工作目录变为根目录,应该不会有人想把根目录卸下吧。关于 chdir 的用法,参见附录 1 当然,在这一步里,如果有特殊的需要,我们也可以把当前工作目录换成其他的路径,比如 /tmp
    4. 将文件权限掩码设为 0 。这需要调用系统调用 umask ,参见附录 3 。每个进程都会从父进程那里继承一个文件权限掩码,当创建新文件时,这个掩码被用于设定文件的默认访问权限,屏蔽掉某些权限,如一般用户的写权限。当另一个进程用 exec 调用我们编写的 daemon 程序时,由于我们不知道那个进程的文件权限掩码是什么,这样在我们创建新文件时,就会带来一些麻烦。所以,我们应该重新设置文件权限掩码,我们可以设成任何我们想要的值,但一般情况下,大家都把它设为 0 ,这样,它就不会屏蔽用户的任何操作。 如果你的应用程序根本就不涉及创建新文件或是文件访问权限的设定,你也完全可以把文件权限掩码一脚踢开,跳过这一步。
    5. 关闭所有不需要的文件。同文件权限掩码一样,我们的新进程会从父进程那里继承一些已经打开了的文件。这些被打开的文件可能永远不被我们的 daemon 进程读或写,但它们一样消耗系统资源,而且可能导致所在的文件系统无法卸下。需要指出的是,文件描述符为 0 1 2 的三个文件(文件描述符的概念将在下一章介绍),也就是我们常说的输入、输出和报错这三个文件也需要被关闭。很可能不少读者会对此感到奇怪,难道我们不需要输入输出吗?但事实是,在上面的第 2 步后,我们的 daemon 进程已经与所属的控制终端失去了联系,我们从终端输入的字符不可能达到 daemon 进程, daemon 进程用常规的方法(如 printf )输出的字符也不可能在我们的终端上显示出来。所以这三个文件已经失去了存在的价值,也应该被关闭。
    下面,就然我们亲眼看一个 daemon 进程的诞生:
    1.14.3 一个 daemon 程序

    /* daemon.c */ #include<unistd.h> #include<sys/types.h> #include <sys/stat.h> #define MAXFILE 65535 main() {          pid_t pid;          int i;         pid=fork();          if(pid<0){                  printf("error in fork/n");                  exit(1);          }else if(pid>0)                  /* 父进程退出 */                  exit(0);          /* 调用setsid */         setsid();          /* 切换当前目录 */         chdir("/");          /* 设置文件权限掩码 */          umask(0);          /* 关闭所有可能打开的不需要的文件 */          for(i=0;i<MAXFILE;i++)                  close(i);          /*             到现在为止,进程已经成为一个完全的daemon进程,             你可以在这里添加任何你要daemon做的事情,如:          */          for(;;)                  sleep(10); }

     
    编译和运行的任务就交给读者们自己完成。 daemon 进程不像其他进程一样有很抢眼的运行结果,基本上它只是毫不声张地做自己的事。你不可能看到任何东西,但可以用 "ps -ajx" 命令观察一下你的 daemon 进程的状态和一些参数。
    1.15 附录
    1.15.1 系统调用 chdir

           #include <unistd.h>        int chdir(const char *path);       

     
    chdir 的作用是改变当前工作目录。进程的当前工作目录一般是应用程序启动时的目录,一旦进程开始运行后,当前工作目录就会保持不变,除非调用 chdir chdir 只有 1 个字符串参数,就是要转去的路径。例如:

    chdir("/");

     
    进程的当前路径就会变为根目录。
    1.15.2 系统调用 setsid

           #include <unistd.h>        pid_t setsid(void);       

     
    一个会话( session )开始于用户登陆,终止于用户退出,在此期间该用户运行的所有进程都属于这个会话,除非进程调用 setsid 系统调用。
    系统调用 setsid 不带任何参数,调用之后,调用进程就会成立一个新的会话,并自任该会话的组长。
    1.15.3 系统调用 umask

           #include <sys/types.h>        #include <sys/stat.h>        mode_t umask(mode_t mask);       

     
    系统调用 umask 可以设定一个文件权限掩码,用户可以用它来屏蔽某些权限,以防止误操作导致给予某些用户过高的权限。

    展开全文
  • 进程管理

    千次阅读 2015-03-07 10:25:18
    1.在进程管理中,当 等待的事件发生 时进程从阻塞状态变为就绪状态. 2.分配到必要的资源并获得处理机时的进程状态是 执行状态 。 3.P、V操作是 两条低级进程通信原语 。 4.对进程的管理和控制使用 原语 。 5...
  • 首先说一下keepalived: Keepalived大致分两层结构:用户空间...Ipvs的作用在前面的章节已经做过描述,不再重复叙述;netlink 提供高级路由及其他相关的网络功能,如果我们在负载均衡器上启用netfilter/ipta...
  • 进程管理—进程描述符(task_struct)

    千次阅读 2017-01-12 09:52:15
    前言当把一个程序加载到内存当中,此时,这个时候就有了进程关于进程,有一个相关的叫做进程控制块(PCB),这个是系统为了方便进行管理进程所设置的一个数据结构,通过PCB,就可以记录进程的特征以及一些信息。...
  • 一文带你怼明白进程和线程通信原理

    千次阅读 多人点赞 2020-02-18 11:46:08
    进程间通信 进程是需要频繁的和其他进程进行交流的。...下面我们会一起讨论有关 进程间通信(Inter Process Communication, IPC) 的问题。 关于进程间的通信,这里有三个问题 上面提到了第一个问题,那就是...
  • 此文章详细叙述了: 进程概念 进程查看 进程退出 进程等待 程序替换
  • 下列关于线程调度的叙述中,错误的是()。 正确答案: B E 你的答案: A E F (错误) 调用线程的sleep()方法,可以使比当前线程优先级低的线程获得运行机会 调用线程的yeild()方法,只会使与当前...
  • 进程间关系

    千次阅读 2017-03-01 22:17:37
    说完了进程,我们来说一下进程间关系。进程组一个或者多个进程的集合,每一个进程除了有一个进程ID之外,它还属于一个进程组。...这里下面的带[]的都是内核进程,可以看到它们都在同一进程组。组长进程:组长进程就是
  • 来源:Java建设者下面是本文的结构图我们平常说的进程和线程更多的是基于编程语言的角度来说的,那么你真的了解什么是线程和进程吗?那么我们就从操作系统的角度来了解一下什么是进程和线程。进程...
  • 在oracle中,有三组进程下面纷纷叙述 1 用户进程(User Process)  也称为客户端进程,用户进程与oracle服务器之间是典型的C/S模式,即服务器端一直打开,当用户进程向oracle服务器发出连接请求时,oracle服务器...
  • 以下接【关于叙述Ubuntu 8.10常用软件,设置,配置 (一)】 12.字体美化设置 系统->首选项->外观->字体 在新的8.10中,建议给所有的安体修改成WenQuanYi Bitmap Song,别的就不用设置了.你会发现比windows还好...
  • 进程通信方式总结与盘点

    万次阅读 多人点赞 2019-11-20 14:25:23
    这里需要和进程同步做一下区分,进程同步控制多个进程按一定顺序执行,进程通信是一种手段,而进程同步是目标。从某方面来讲,进程通信可以解决进程同步问题。 ​ 首先回顾下我们前面博文中讲到的信号量机制,为了...
  • linux进程管理原理

    万次阅读 2017-08-16 05:09:57
    Linux 是一种动态系统,能够适应不断变化的计算需求。... 在用户空间,进程是由进程标识符(PID)表示的。从用户的角度来看,一个 PID 是一个数字值,可惟一标识一个进程。一个 PID 在进程的整个生命期间不会更
  • 简单叙述钩子实现

    千次阅读 2010-01-15 09:17:00
    由于做实验,要把自己的DLL注入到所有进程,在Win7和Vista下的环境使用远程线程,比较费力气因为数据执行保护(DEP)有防御 最后选择消息钩子来实现。 1.钩子中对HOOK消息的处理部分要在DLL中实现,然后导出这个...
  • 进程 - 2

    千次阅读 2018-09-26 16:45:19
    1.下列进程调度算法中,综合考虑进程等待时间和执行时间的是() 时间片轮转调度算法 短进程优先调度算法 先来先服务调度算法 高响应比优先调度算法 解析: 在高响应比优先调度算法中,选出...
  • 进程的描述

    2019-08-27 21:06:54
    进程的定义和特征  1. 进程的定义 对于进程的定义,从不同的角度可以有不同的定义,其中较典型的定义有:  (1) 进程是程序的一次执行。  (2) 进程是一个程序及其数据在处理机上顺序执行时所发生的活动。  (3) ...
  • 下面关于并发性的叙述中正确的是:并发性是指若干事件在同一时间间隔发生 一般来说,为了实现多道程序设计,计算机最需要更大的内存 Unix操作系统的进程控制块中常驻内存的是proc结构 当(时间片到)时,进程从...
  • 进程管理(一)

    2017-04-30 16:51:40
    一.进程概念:  程序的一个执行实例  ...操作系统对进程进行管理,都是对结构体数据(PCB(进程描述符,是一个结构体,包含了进程的所有描述信息))进行管理  进程与可执行程序的区别:  1>
  • 进程管理1.1 进程描写叙述符及任务结构1.1.1 task_struct 重要成员说明1.1.2 thread_info与内核栈1.1.2.1 内核栈1.1.2.2 thread_info1.2 0号进程1.3 init进程:1号进程1.4 kthread进程:2号进程1.5 进程创建1.5.1 ...
  • 进程的上下文切换

    千次阅读 2013-07-21 12:33:39
    进行进程切换就是从正在运行的进程中收回处理器,然后再使待运行进程来占用处理器。 这里所说的从某个进程收回处理器,实质上就是把进程存放在处理器的寄存器中的中间数据找个地方存起来,从而把处理器的寄存器腾...
  • Linux 进程管理

    千次阅读 2011-01-11 09:33:00
    1. 进程的概念  Linux是一个多用户多任务的操作系统。多用户是指多个用户可以在同一时间使用同一个linux系统;多任务是指在Linux下可以同时执行多个任务,更详细的说,linux采用了分时管理的方法,所有的任务都...
  • 近期被一些朋友问到关于进程保活这块的知识点,想必是很多开发者研究的重点,虽然我不支持做成这类【流氓软件】,因为大家都这么干的话,Android系统的内存永远不够用,电量消耗的贼快,流畅度肯定就大大的降低了;...
  • 进程的基本概念

    万次阅读 2018-11-08 23:14:34
    1.什么是进程?  1. 进程就是运行起来的程序,程序运行起来需要被加载到内存中。(这是站在用户的角度看待进程的)  2. 进程就是操作系统的描述,这个描述叫PCB(进程控制块),Linux下PCB有自己的名字叫task_...
  • 文章目录2.4 进程同步2.5 经典的进程同步问题2.6 管程2.7 进程通信2.8 线程及其实现2.9 本章要点与课堂练习 2.4 进程同步 2.5 经典的进程同步问题 2.6 管程 2.7 进程通信 2.8 线程及其实现 2.9 本章要点与课堂练习 ...
  • android java进程管理(一)之进程模型

    万次阅读 2017-03-30 09:05:09
    android 操作系统的进程模型本地进程和Java进程的关系记得曾经在研究gnome桌面系统的时候,看到开发者的一句话:面对一个庞大的开源项目,就像把我们扔到一个一线城市的市中心,然后让你通过自己的双脚丈量出整个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,458
精华内容 8,183
关键字:

下面关于进程的叙述