linux 进程概念

1，pcb：进程控制块结构体：/usr/src/linux-headers-4.15.0-29/include/linux/sched.h

• 进程id：系统中每个进程有唯一的id，在c语言中用pid_t类型表示，是个非负整数。

• 进程状态：就绪，运行，挂起，停止等状态

• 描述虚拟地址空间的信息

• 描述控制终端的信息

• 进程执行时的当前工作目录（current working directory）

• umask掩码

• 文件描述符表，包含很多指向file结构体的指针

• 和信号相关的信息

• 用户id和组id

• 会话（session）和进程组

• 进程可以使用的资源上限（resource limit）

  用【ulimit -a】查看：

  ys@ys:~$ ulimit -a
  core file size          (blocks, -c) 0
  data seg size           (kbytes, -d) unlimited
  scheduling priority             (-e) 0
  file size               (blocks, -f) unlimited
  pending signals                 (-i) 7743
  max locked memory       (kbytes, -l) 16384
  max memory size         (kbytes, -m) unlimited
  open files                      (-n) 1024
  pipe size            (512 bytes, -p) 8
  posix message queues     (bytes, -q) 819200
  real-time priority              (-r) 0
  stack size              (kbytes, -s) 8192
  cpu time               (seconds, -t) unlimited
  max user processes              (-u) 7743
  virtual memory          (kbytes, -v) unlimited
  file locks                      (-x) unlimited

2，环境变量

查看所有的环境变量：env

环境写法：等号前后没有空格

key=value

常用的环境变量：

• path：可执行文件的搜索路径。比如可以直接敲ls，那是因为ls的可执行文件在环境变量path里，所以系统找得到。但是比如a.out执行文件，就不能直接敲a.out，因为a.out不在path里。
• shell：当前使用的shell程序，通常是：/bin/bash
• term：当前使用的终端类型，如果是图像界面的话，一般为：xterm-256color
• lang：当前的语言和字符编码，一般为：en_us.utf-8
• home：当前用户所在的绝对路径。

获取环境变量：getenv

#include <stdlib.h>
char *getenv(const char *name);

返回值：

• 成功：返回指针

• 失败：返回null

设置环境变量：setenv

#include <stdlib.h>
int setenv(const char *name, const char *value, int overwrite);

删除环境变量：unsetenv

#include <stdlib.h>
int unsetenv(const char *name);

设置环境变量和删除环境变量一般不用系统函数，而是编辑【~/.bashrc】文件。

使用【exprot key=value】。

3，进程概念

创建进程：fork

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

• 返回值
  • 失败：-1
  • 成功：返回2次
    • 父进程中返回：子进程的id
    • 子进程返回：0

获得当前进程自己id：getpid

获得当前进程的父进程的id：getppid

ss
#include <unistd.h>

pid_t getpid(void);
pid_t getppid(void);

理解fork的小例子：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main(){
  //char* val = getenv("home");
  printf("begin...\n");
  pid_t pid = fork();
  printf("end...\n");
}

执行结果：

ys@ys:~/test$ ./en 
begin...
end...
ys@ys:~/test$ end...

从执行结果发下：

1，【begin】被打印出1次；【end】被打印出2次。

2，第二个【end】跑到了shell的后面。

分析：

• 从执行结果1可以看出来，fork后，从1个进程，又分出了一个子进程。并且子进程不是从程序的开头开始执行，而是从fork后面开始执行，这个理解至关重要。
• 执行结果2现象的解释，根本原因是父进程比子进程先执行结束了，导致了子进程成为了孤儿进程。最开始shell进程把执行权交给程序，也就是父进程，当父进程结束后，shell又接管终端，可是这个时间点，子进程还没结束，子进程的打印语句就把【end】打印到了shell后面。

下面的例子可以了解，getpid和getppid的用法：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main(){
  //char* val = getenv("home");
  printf("begin...\n");
  pid_t pid = fork();

  //child process
  if(pid == 0){
    printf("child: pid=%d, ppid=%d\n", getpid(), getppid());
  }
  //parent proces
  else if(pid > 0){
    printf("parent: pid=%d, child id:%d\n", getpid(), pid);
    sleep(1);//为了让子进程先结束
  }
  printf("end...\n");
}

查看进程的命名：ps

• 选项a：显示更多信息
• 选项u：显示用户信息
• 选项x：和选项a一起使用
• 选项j：能看到父进程

ys@ys:~$ ps aux
user       pid %cpu %mem    vsz   rss tty      stat start   time command
root         1  0.0  0.3 159928  7536 ?        ss   13:53   0:02 /sbin/init spla
root         2  0.0  0.0      0     0 ?        s    13:53   0:00 [kthreadd]
ys        4029  0.0  0.0   4508   812 pts/0    s+   16:30   0:00 ./en
ys        4030  0.0  0.0   4508    80 pts/0    s+   16:30   0:00 ./en
ys        4043  0.1  0.2  29560  4936 pts/1    ss   16:30   0:00 bash
ys        4051  0.0  0.1  44472  3700 pts/1    r+   16:30   0:00 ps aux

从下图可以看出子进程4030的父进程是4029，父进程4029的父进程是1671，进程1671是bash(shell)程序。所以的进程都是从进程1：【/sbin/init splash】衍生出来的。

ys@ys:~$ ps ajx
 ppid   pid  pgid   sid tty      tpgid stat   uid   time command
    0     1     1     1 ?           -1 ss       0   0:02 /sbin/init splash
 1661  1671  1671  1671 pts/0     4029 ss    1000   0:00 bash
 1671  4029  4029  1671 pts/0     4029 s+    1000   0:00 ./en
 4029  4030  4029  1671 pts/0     4029 s+    1000   0:00 ./en
 1661  4043  4043  4043 pts/1     4055 ss    1000   0:00 bash
 4043  4055  4055  4043 pts/1     4055 r+    1000   0:00 ps ajx

给进程发送信号：kill

使用【kill -l】查看信号列表，发现9号信号就杀死进程的信号。

ys@ys:~$ kill -l
 1) sighup   2) sigint   3) sigquit  4) sigill   5) sigtrap
 6) sigabrt  7) sigbus   8) sigfpe   9) sigkill 10) sigusr1
11) sigsegv 12) sigusr2 13) sigpipe 14) sigalrm 15) sigterm
16) sigstkflt   17) sigchld 18) sigcont 19) sigstop 20) sigtstp
21) sigttin 22) sigttou 23) sigurg  24) sigxcpu 25) sigxfsz
26) sigvtalrm   27) sigprof 28) sigwinch    29) sigio   30) sigpwr
31) sigsys  34) sigrtmin    35) sigrtmin+1  36) sigrtmin+2  37) sigrtmin+3
38) sigrtmin+4  39) sigrtmin+5  40) sigrtmin+6  41) sigrtmin+7  42) sigrtmin+8
43) sigrtmin+9  44) sigrtmin+10 45) sigrtmin+11 46) sigrtmin+12 47) sigrtmin+13
48) sigrtmin+14 49) sigrtmin+15 50) sigrtmax-14 51) sigrtmax-13 52) sigrtmax-12
53) sigrtmax-11 54) sigrtmax-10 55) sigrtmax-9  56) sigrtmax-8  57) sigrtmax-7
58) sigrtmax-6  59) sigrtmax-5  60) sigrtmax-4  61) sigrtmax-3  62) sigrtmax-2
63) sigrtmax-1  64) sigrtmax

由父进程创建5个子进程的例子：

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main(){
  int i = 0;
  pid_t pid = 0;
  for(i = 0; i < 5; ++i){
    pid = fork();
    if(pid == 0){
      //child process
      //printf("child: pid=%d, ppid=%d\n", getpid(), getppid());
      break;
    }
    else if (pid > 0){
      //parent process
      //printf("parent: pid=%d, ppid=%d\n", getpid(), getppid());
    }
  }

  sleep(i);
  printf("proces:%d will die:pid=%d,ppid=%d\n", i,getpid(), getppid());
  
}

执行结果：

ys@ys:~/test$ ./fo
proces:0 will die:pid=2139,ppid=2138
proces:1 will die:pid=2140,ppid=2138
proces:2 will die:pid=2141,ppid=2138
proces:3 will die:pid=2142,ppid=2138
proces:4 will die:pid=2143,ppid=2138
proces:5 will die:pid=2138,ppid=1704

要点在【break】和【sleep(i)】这2个地方。

不加break的话，子进程也会创建子进程。

观察【sleep(i);]这行，执行到这行的时间点，如果i=0，则说明是第一创建的子进程；

如果i=4，说明是最后创建的子进程，如果i=5，说明是父进程。所以根据i的值，进行sleep，就能够实现先创建的子进程先执行完，后创建的后执行完，最后才是父进程执行完。

在当进程调用别的程序：execl和execlp

#include <unistd.h>
int execl(const char *path, const char *arg, .../* (char  *) null */);
int execlp(const char *file, const char *arg, .../* (char  *) null */);

• execl
  • path：目标程序的所在路径和程序名。例：【/bin/ls】
  • arg：目标程序的参数。注意第一个参数必须是程序自己的名字。
  • null：最后一个参数必须是null，告诉它参数列表到这里结束了。
  • 返回值：
    • 成功：就不返回了，直接走了，也就是说，调用execl的语句之后的代码都不被执行了。
    • 失败：-1
• execlp：多了个p的含义就是：这个函数自己会去搜索环境变量path。
  • file：目标程序名，不用加路径。例：【ls】
  • arg：目标程序的参数。注意第一个参数必须是程序自己的名字。
  • null：最后一个参数必须是null，告诉它参数列表到这里结束了。
  • 返回值：
    • 成功：就不返回了，直接走了，也就是说，调用execl的语句之后的代码都不被执行了。
    • 失败：-1

调用ls的例子：

#include <unistd.h>
#include <stdio.h>
int main(){
  execl("/bin/ls", "ls", "-l", "--color=auto", null);
  perror("ls");
  printf("not back\n");
}

孤儿进程和僵尸进程

孤儿进程：父进死了，被init进程领养，变成孤儿进程。

僵尸进程：子进程死了，但父进程没有回收子进程的资源（pcb（大结构体）），变成僵尸进程。

回收僵尸进程的方法：不能再用kill去杀，杀死父进程，让init领养，init负责回收。

查看僵尸进程：

 ppid   pid  pgid   sid tty      tpgid stat   uid   time command
 1704  2683  2683  1704 pts/0     2683 s+    1000   0:00 ./zo
 2683  2684  2683  1704 pts/0     2683 z+    1000   0:00 [zo] <defunct>

发现有【z+】和《defunct》就是僵尸进程。

回收子进程：wait函数

#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *wstatus);

• 作用：

  • 阻塞等待（如果子线程还没有死亡，则一直等到它死亡）
  • 回收子进程的资源（pcb结构体）
  • 查看死亡的原因

• wstatus：传出参数，里面有子进程死亡的原因。

  查看wstatus的方法：使用下面2组宏。

  wifexited(wstatus)
  wexitstatus(wstatus)
  
  wifsignaled(wstatus)
  wtermsig(wstatus)

  • 正常死亡：wifexited(wstatus)返回真，使用wexitstatus(wstatus)得到退出状态。

    退出状态的具体含义：return 后面的数字；或者exit 括号里的数字。

  • 非正常死亡（被信号杀死）：wifsignaled(wstatus)返回真，使用wtermsig(wstatus)得到杀死它的信号（kill -l 显示出来的数字)。

• 返回值：

  • 成功：返回死亡子进程的pid
  • 失败：-1

wait的例子：

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <wait.h>
#include <stdlib.h>

int main(){
  int i = 0;
  pid_t pid = 0;

  pid = fork();
  if(pid == 0){
    //child process
    while(1){
      printf("child: pid=%d, ppid=%d\n", getpid(), getppid());
      sleep(3);
      //return 101;
      //exit(111);
      //sleep(2);
    }
  }
  else if (pid > 0){
    //parent process
    printf("parent: pid=%d, ppid=%d\n", getpid(), getppid());
    int wstatus;
    pid_t pid = wait(&wstatus);
    if(wifexited(wstatus)){
      printf("child die pid=%d, status=%d\n",pid, wexitstatus(wstatus));
    }
    if(wifsignaled(wstatus)){
      printf("child die pid=%d, status=%d\n",pid, wtermsig(wstatus));
    }
  }
}

分析：

• 正常死亡，代码用return和exit来模拟的
• 被信号杀死：在另一终端里使用【kill pid】后，返回的wtermsig(wstatus)为15（sigterm）；如果用【kill -9 pid】则wtermsig(wstatus)为9（sigkill）

回收子进程：waitpid

#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);

• pid
  • < -1：回收组id为-pid的子进程
  • -1：回收所有的子进程
  • 0：回收和调用进程的组id相同的组id的所有子进程。
  • 》0：回收指定pid的子进程
• wstatus：和wait一样
• options：
  • 0：与wait功能相同。
  • wnohang：如果执行waitpid的时点，子进程还没结束，会立刻返回，不阻塞。
• 返回值：返回状态发生了变化的子进程的id。
  • 调用时设置了wnohang并且还指定了1个或者多个子进程
    • 如果有子进程退出了，返回退出了的子进程的pid
    • 如果没有子进程退出，返回0
  • 失败：-1（没有子进程了，子进程都被回收完了）