Linux-进程概念讲解

1、进程的基本概念

在给进程下定义之前，我们先了解一下进程：

我们在编写完代码并运行起来时，在我们的磁盘中会形成一个可执行文件，当我们双击这个可执行文件时（程序时），这个程序会加载到内存中，而这个时候我们不能把它叫做程序了，应该叫做进程。

所以说，只要把程序（运行起来）加载到内存中，就称之为进程。

进程的概念：程序的一个执行实例，正在执行的程序等

2、描述进程-PCB

PCB：进程控制块（结构体）（process control block的缩写）

当一个程序加载到内存中，操作系统要为刚刚加载到内存的程序创建一个结构体（PCB）,进程信息被放在这个结构体中（PCB）,可以理解为PCB是进程的属性的集合。

• 在Linux操作系统下的PCB是：task_struct

• task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息

在进程执行时，任意时间内，进程对应的PCB都要以下内容：

• 标示符：描述本进程的唯一标示符，用来区别其他进程

• 状态：任务状态

• 优先级：相对于其他进程的优先级

• 程序计数器：程序中即将被执行的下一条指令的地址

• 内存指针：包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块指针

• 上下文数据：进程执行时处理器的寄存器中的数据

• I/O状态信息：包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表

• 记账信息：可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等

• 其他信息：…

优先级的理解：

由于CPU只要一个，进程可以有多个，所以CPU的资源有限，操作系统在调度进程到CPU时会根据进程的优先级来判断。

程序计数器的理解：

CPU跑一个进程时，要执行它的代码，而代码是自上往下执行的（if、else、循环等除外），CPU先要取指令，然后分析指令，再然后执行指令。取完一个指令后，CPU中的寄存器（EIP指令寄存器）会保存当前指令的下一条指令的地址，方便下次取下一个指令。所谓的函数跳转、分支判断、循环等，都是修改EIP完成的。

上下文数据的理解：

CPU在跑一个进程时，没有跑完就开始切换其他进程，为了下次继续跑完这个进程，会保留这个进程的上下文数据，当这个进程回来时，会把上下文数据移动到CPU内部继续执行。

所以为什么会存在进程控制块PCB呢？

操作系统要进行软硬件的资源管理，要管理资源就要先对资源描述再组织，要描述就必须有PCB结构体。Linux中可以在内核里找到task_struct，所有运行在系统里的进程都以task_struct链表的形式存在内核里。

3、通过系统调用获取进程标示符

在Linux中查看进程信息，使用命令ps aux

例如，我写了一份test.c的程序，./test运行之后，可以使用命令

ps aux | grep test | grep -V grep

说明一下，grep是查找命令，后面跟上-V是过滤信息。

下面开始说明，程序中如何获取进程标识符。

• 进程id（PID）

• 父进程id（PPID）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
    printf("pid: %d\n", getpid());
    printf("ppid: %d\n", getppid());
    return 0;
}

其中getpid()是找进程的标示符，getppid()找父进程的标示符

4、通过系统调用创建进程-fork初识

• fork有两个返回值

• 父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
    int ret = fork();
    printf("hello proc : %d!, ret: %d\n", getpid(), ret);
    sleep(1);
    return 0;
}

fork之后通常要用if进行分流，fork函数使用代码如下所示。

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
    int ret = fork();
    if (ret < 0) {
        perror("fork");
        return 1;
    }
    else if (ret == 0) { //child
        printf("I am child : %d!, ret: %d\n", getpid(), ret);
    }
    else { //father
        printf("I am father : %d!, ret: %d\n", getpid(), ret);
    }
    sleep(1);
    return 0;
}

这段代码有两个进程，并且它们的关系是父子关系。

什么是fork函数：

在调用fork函数之前，只有一个进程(父进程)，当这个进程调用fork函数之后，fork函数会复制一个进程(子进程)，区别是PID不同，它们的关系是父子关系。

fork函数会返回两次值：

给父进程返回子进程的pid。

给子进程返回0。

失败时，在父进程中返回-1，不创建子进程，并且errno被适当地设置。

5、进程状态

为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务）。

下面的状态在kernel源代码里定义：

/*
* The task state array is a strange "bitmap" of
* reasons to sleep. Thus "running" is zero, and
* you can test for combinations of others with
* simple bit tests.
*/
static const char* const task_state_array[] = {
"R (running)", /* 0 */
"S (sleeping)", /* 1 */
"D (disk sleep)", /* 2 */
"T (stopped)", /* 4 */
"t (tracing stop)", /* 8 */
"X (dead)", /* 16 */
"Z (zombie)", /* 32 */
};

• R运行状态（running） : 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。

• S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））。

• D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。

• T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。

• X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态

R 可执行状态

通过命令ps aux

进程中的R状态不代表正在运行，代表的可被调度，此运行相当于上面的就绪态。

操作系统会把进程中R状态的进程全放在调度队列中，方便调度

S 睡眠状态

用代码创建一个睡眠状态的进程：

1. 创建了一个可执行态进程

#include<stdio.h>
#include<unistd.h>
int main() 
{
    while(1);
    return 0;
}

2. 创建休眠态进程

#include<stdio.h>
#include<unistd.h>
int main() 
{
    while(1)
    sleep(10);
    return 0;
}

S状态是浅度睡眠，随时可以被唤醒，也可以被杀掉。

D 磁盘休眠状态

可以表示为深度睡眠，该进程不会被杀掉，即使你是操作系统，除非我自动唤醒，才可以恢复。

T 暂停状态

向进程发送SIGSTOP信号，该进程会响应该信号进入暂停状态，

向该进程发送SIGCONT信号，该进程会从暂停状态恢复到可执行状态。

Z 僵尸状态

• 僵尸状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用,后面讲）没有读取到子进程退出的返回代码时就会产生僵尸进程

• 僵尸进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。

• 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

举个例子：

一个人突然死亡，普通人不会对现场进行清理，而是报警等警察和法医对该人进行信息的采集，之后才清理现场。

其中，某人充当的角色是进程、警察和法医充当的角色的父进程或者操作系统。

#include <stdio.h>
#include <stdlib.h>
int main()
{
    pid_t id = fork();
    if (id < 0) {
        perror("fork");
        return 1;
    }
    else if (id > 0) { //parent
        printf("parent[%d] is sleeping...\n", getpid());
        sleep(30);
    }
    else {
        printf("child[%d] is begin Z...\n", getpid());
        sleep(5);
        exit(EXIT_SUCCESS);
    }
    return 0;
}

编译并在另一个终端下启动监控

开始测试

看到结果

僵尸进程危害

• 进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！

• 维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说， Z状态一直不退出， PCB一直都要维护？是的！

• 那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间

孤儿进程

• 父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？

• 父进程先退出，子进程就称之为“孤儿进程”

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    pid_t id = fork();
    if (id < 0) {
        perror("fork");
        return 1;
    }
    else if (id == 0) {//child
        printf("I am child, pid : %d\n", getpid());
        sleep(10);
    }
    else {//parent
        printf("I am parent, pid: %d\n", getpid());
        sleep(3);
        exit(0);
    }
    return 0;
}

6、进程优先级

基本概念

• cpu资源分配的先后顺序，就是指进程的优先权（priority）

• 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能

• 还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能

查看系统进程

在linux或者unix系统中，用ps –l命令则会类似输出以下几个内容：

我们很容易注意到其中的几个重要信息，有下：

• UID : 代表执行者的身份

• PID : 代表这个进程的代号

• PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号

• PRI ：代表这个进程可被执行的优先级，其值越小越早被执行

• NI ：代表这个进程的nice值

PRI and NI

• PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高

• 那NI呢?就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值

• PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为： PRI(new)=PRI(old)+nice

• 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行

• 所以，调整进程优先级，在Linux下，就是调整进程nice值

• nice其取值范围是-20至19，一共40个级别

需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。

可以理解nice值是进程优先级的修正修正数据

查看进程优先级的命令

用top命令更改已存在进程的nice值：

• top

• 接着按r然后输入进程的PID输入nice值

其他概念

• 竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级

• 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰

• 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行

• 并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发

7、环境变量

基本概念

1. 环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数

2. 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性(可以被子进程继承)

示例：

我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找

常见的环境变量

• PATH : 指定命令的搜索路径

• HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)

• SHELL : 当前Shell,它的值通常是/bin/bash

查看环境变量：

echo $NAME //NAME:你的环境变量名称

例如，echo $PATH

测试PATH

以PATH为例，展现环境变量的作用

#include <stdio.h>
int main()
{
    printf("hello world!\n");
    return 0;
}

结果为：像这样执行命令，前面加上./表示的是当前路径下。

为什么有些指令可以直接执行，不需要带路径，而我们的二进制程序需要带路径才能执行？

1. 执行程序前，系统会在特定路径下查找对应程序

2. 而PATH的作用是辅助系统进程指令查找，PATH变量储存的就是可能存在指令或者程序的路径

那么，如何将程序所在路径加入环境变量PATH当中

使用指令 export PATH=$PATH:"path" "path"表示的是要添加的路径

注：该添加方法只在当前有用，退出Linux后则会恢复，想永久设置则需在环境变量文件中进行添加

测试HOME

对比效果：root和普通用户执行echo $HOME

解释：

一个用户默认所处的路径是由环境变量HOME决定的，环境变量HOME是决定用户所处的主工作目录的

与环境变量相关的命令

• echo: 显示某个环境变量值

• export: 设置一个新的环境变量

• env: 显示所有环境变量

• unset: 清除环境变量

• set: 显示本地定义的shell变量和环境变量

环境变量的组织方式

解释：

每个程序都会收到一张环境表，环境表是一个字符指针数组，每个指针指向一个以’\0’结尾的环境字符串

如何获取环境变量

1. 命令行参数

示例：

#include <stdio.h>
int main(int argc ,char *argv[] ,char* env[])//命令行参数个数、命令行参数、环境变量 
{
   int i = 0;
   for(; env[i]; i++)  //遍历env指针数组打印环境变量的值
   {
     printf("env[%d]：%s\n", i, env[i]);                           
   }
   return 0;
}

结果：

2. 通过第三方变量environ获取

示例：

#include <stdio.h>
int main(int argc, char *argv[])
{
    extern char **environ;
    int i = 0;
    for(; environ[i]; i++)
    {
        printf("%s\n", environ[i]);
    }
    return 0;
}

结果：

注意：libc中定义的全局变量environ指向环境变量表，environ没有包含在任何头文件中，所以在使用时要用extern声明

3. 通过系统调用获取或设置环境变量

示例：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    printf("PATH:%s\n", getenv("PATH"));
    return 0;
}

常用getenv和putenv函数来访问特定的环境变量