Linux -- Chapter 11 进程与信号

Chapter 11 进程与信号
 进程与信号构成了Linux操作环境的基础部分。
 如何在自己的程序中启动和停止其他的进程，如何让进程收发消息，如何避免僵尸进程。
 大纲 『
  (1) 进程的结构、类型和调度
  (2) 用不同的方法启动新进程
  (3) 父进程、子进程和僵尸进程
  (4) 什么是信号以及如何使用它们
』
11.1 什么是进程？
 进程由程序代码、数据、变量(占用着系统内存)、打开的文件和环境组成。
 Linux系统会在进程之间共享程序代码和系统函数库，所以在任何时刻内存中都只有代码的一份副本。
 Linux系统本身会运行着一些管理系统资源和控制用户访问的程序。
11.2 进程的结构 
 user : neil 和 user : rick 它们同时运行 grep 程序查找不同字符串。
          neil                               rick
   $ grep kirk trek.txt              $ grep troi nextgen.doc
           PID 101                           PID 102
            代码   ----> grep程序代码 <----    代码
         数据s="kirk"                       数据s="troi"
           函数库  ---->  C语言函数   <-----    函数库
            文件                                文件
  PID 2 ~ 32768
  init进程负责管理其他进程。
 程序代码是以只读的方式加载到内存中的，虽然不能对这个区域执行写操作，但它可以被多
 个进程安全地共享。
 @1, 共享函数库带来的另一个优点 ： 包含可执行程序grep的磁盘文件比较小。
                             因为它不包含共享函数库代码。
 @2，并不是程序在运行时，所需要的所有东西都可以被共享。例如：进程使用的变量，进程通过
      各自的文件描述符来访问文件。
 @3，进程有自己的桟空间，还有自己的环境变量。进程还必须维护自己的程序计数器。
      计数器用来记录它执行到的位置。即在执行线程中的位置。
        在使用线程时，进程可以有不止一个执行线程。
 @4，Linux， 在目录/proc中有一组特殊的文件，这些文件的特殊之处允许你
             “窥视”正在运行进程的内部情况。（类似于看目录里的文件一样）
11.2.1-进程表
  Linux进程表就像一个数据结构，它把当前加载到内存中的所有进程的有关信息保存在一个
    表中，其中包括进程的PID，进程的状态，命令字符串和其他一些PS命令输出的各类信息。
  OS通过进程的PID对它们进行管理，这些PID是进程表的索引。
   进程表的长度是有限制的，所以系统能够支持的同时运行的进程数也是有限制的。
11.2.2-查看进程
  ps -ef
  启动新进程并等待它们结束的能力是整个系统的基础。
 显示出来的进程只表示它是准备好运行，并不表示它正在运行，因为时间片很短。
 @3，Linux内核用进程调度器来决定下一个时间片应该分配给哪个进程。
         判断依据是进程的优先级。高的运行的更频繁。
         抢先式多任务处理，所以进程的挂起和继续运行无需彼此之间的协作。
    在一个如Linux这样的多任务系统中，多个程序可能会竞争使用同一资源。
    执行短期的突发性工作并暂停运行来等待输入的程序，要比持续占用处理器
   不断轮询来查看是否有新的输入到达的程序要更好。
   我们称表现良好的程序是nice程序。OS根据进程的nice值来决定它的优先级。
   我们可以用nice命令设置进程的nice值，使用renice命令调整它的值。
 @4，在某些情况下，只要还有高优先级的进程可以运行，低优先级
      的进程就根本不能运行。
11.3 启动新进程
#include <stdio.h>
#include <stdlib.h>
int main() {
    printf("Running ps with system\n");
    system("ps ax");
    printf("Done.\n");
    exit(0);
}
   system()函数用一个shell来启动想要执行的程序，所以可以把这个程序放到后台执行。
         局限性 ： 程序还必须要等待由 system 函数启动的进程结束之后才能继续。
 @2，创建进程的底层接口exec
     使用system函数远非启动其他进程的理想手段，它依赖shell, 还效率不高！
  1，替换进程映像
   exec 系列函数由一组相关的函数组成，他们在进程的启动方式和程序参数的
    表达方式各有不同。
  2，复制进程映像
    要想让进程同时执行多个函数，我们可以使用线程或者从原程序中创建
    一个完全分离的进程，后者就像init的做法一样，而不像exec替换线程
    我们可以通过调用fork创建一个新进程。这个系统调用复制当前进程，
    在进程表中创建一个新的表项，新表项中的许多属性与当前进程是相同的
    。但新进程有自己的数据空间，环境和文件描述符。fork和exec函数结合
    在一起使用就是创建新进程所需要的一切。
    最初的进程
        |
        V
      fork() --------------------
        |                        |
        V                        V
    返回一个新的PID             返回0
        |                        |
        V                        V
   原进程继续执行               新进程


   父进程中的fork()调用返回的是子进程的PID。子进程中的fork()调用返回的是0.
   pid_t new_pid;
   new_pid = fork();
   switch(new_pid) {
       case -1 :    // Error
            break;
       case 0 :     // we are child
            break;
       default :    // we are parent
            break;
   }
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>


int main() {
    pid_t pid;
    char *message;
    int n;
    printf("fork program starting\n");
    pid = fork();
    switch(pid) {
        case -1 :
            perror("fork failed");
            exit(1);
        case 0 :
            message = "This is the child";
            n = 5;
            break;
        default :
            message = "This is the parent";
            n = 3;
            break;
    }
    for(; n > 0; n--) {
        puts(message);
        sleep(1);
    }
    exit(0);
}
hp@ubuntu:~/linux$ ./fork1
fork program starting
7594
This is the parent
0
This is the child
This is the parent
This is the child
This is the parent
This is the child
This is the child
hp@ubuntu:~/linux$ This is the child
 3,等待一个进程
   当用fork启动一个子进程时，子进程就有了它自己的生命周期并将独立运行。
 wait系统调用将暂停父进程直到它的子进程结束为止。
 4，僵尸进程
  用fork来创建进程确实很有用，但你必须清楚子进程的运行情况。
  子进程终止时，它与父进程之间的关联还会保持，直到父进程也
  正常终止或父进程调用wait才告结束。因此，进程表中代表子进程
  的表项不会立刻释放。虽然子进程已经不再运行，但它仍然存在于
  系统中，因为它的退出码还需要保存起来，以备父进程今后的wait调用
  使用。这时它将成为一个死进程或僵尸进程。
 5，如果父进程异常终止，子进程就自动把PID为1的进程init作为自己的父进程。
   子进程已经是一个不再运行的僵尸进程，但因为其父进程异常终止，所以它由
   init接管，僵尸进程将一直保留在进程表中直到被init进程发现并释放。进程表
   越大，这一过程越慢，应该尽量避免zombie因为它一直消耗系统资源。
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *stat_loc, int options); WNOHANG
11.3.3 输入输出重定向
11.3.4 线程
Linux系统中的进程可以互相协作，互相发送消息，互相中断，甚至可以共享内存段
 但是他们是自个独立的实体，要想在它们之间共享变量很难。线程程序不好写。 
11.4 信号
 信号 ： 响应某些条件而产生的一个事件。信号由shell和终端处理器生成来引起中断。
   可进程间传递消息或修改行为的一种方式。信号可被 ：  生成，捕获，响应，忽略。
   #include <signal.h>
   SIGKILL
   SIGSEGV
   SIGABORT ...
   核心转储文件 core ,  SIGCONT
 例 ：
  $ kill -HUP 512
  $ killall -HUP inetd
  使用信号并挂起程序的执行是Linux程序设计中一个重要部分。等事发生。。
  在只有一个CPU的多用户环境中尤其重要，进程共享着一个处理器，繁忙等待
  将对系统效率带来很大的影响。
 库函数 #include <signal.h>
 void (*signal(int sig, void (*func)(int)))(int); 实验 ： 信号处理 407P
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void ouch(int sig) {
    printf("OUCH! - I got signal %d\n", sig);
    (void) signal(SIGINT, SIG_DFL); // 恢复默认
}
int main() {
    (void) signal(SIGINT, ouch);
    while(1) {
        printf("Hello World!\n");
        sleep(1);
    }
    return 0;
}
/**Output
Hello World!
Hello World!
^COUCH! - I got signal 2
Hello World!
Hello World!
Hello World!
*/
// sigaction 一个健壮的信号接口
/****************************************************8
 * #include <sys/types.h>
 * #include <signal.h>
 * int kill(pid_t pid, int sig);
 * kill函数把参数sig给定的信号发送给由参数pid给出的进程号所指定的进程，成功时它返回0
 * kill调用会在失败时返回-1, 并设置errno变量。失败的原因可能是：给定的信号无效(errno-EINVAL)
 *   发送进程权限不够(errno设置为EPERM);目标进程不存在(errno-ESRCH)
 * #include <unistd.h>
 * unsigned int alarm(unsigned int seconds); SIGALRM
 * 
 */
#include <stdio.h>
#include <unistd.h>  /// int pause(void), fork(), sleep(), getppid()
#include <stdlib.h>
#include <sys/types.h> /// 2->kill
#include <signal.h>
static int alarm_fired = 0;
void ding(int sig) {
alarm_fired = 1;
}
int main() {
    pid_t pid;
    printf("alarm application starting\n");
    pid = fork();
    if(pid == -1) {
        perror("fork failed");
        exit(1);
    }
    else if(pid == 0) {
        sleep(5);
        kill(getppid(), SIGALRM);
        exit(0);
    }
    else {
        printf("waiting for alarm to go off\n");
        (void) signal(SIGALRM, ding);
        pause();
        if(alarm_fired) {
            printf("Ding\n");
        }
        printf("done\n");
    }
    return 0;
}
/// sigsuspend
// 感悟 ： 检查和信号相关的代码时总是要非常小心
* Chapter 12 线程 (略)