写点什么

Linux 系统 - 进程概念

作者:可口也可樂
  • 2022-10-22
    湖南
  • 本文字数:6346 字

    阅读完需:约 21 分钟

Linux系统-进程概念

@TOC

零、前言

本章主要讲解操作系统的一些基础概念知识,为进程的学习做铺垫

一、冯诺依曼体系结构

  • 概念:


冯诺依曼体系结构规定了硬件上的数据流动,而大部分计算机都遵守冯诺依曼体系,如笔记本,服务器等


  • 示图:



  • 计算机基本硬件组成:


  1. 输入单元:包括键盘, 鼠标,扫描仪, 写板等

  2. 中央处理器(CPU):含有运算器和控制器等

  3. 输出单元:显示器,打印机等

  4. 存储器:物理内存


注:输入单元和输出单元统称外设


  • 工作原理:


执行程序时,输入设备的数据先预加载到存储器中,通过存储器将数据交给 cpu 进行处理,cpu 再将得到的结果预写入写回存储器,最后再由存储器将结果刷新到输出设备上


  • 注意:


  1. 不考虑缓存情况 CPU 能且只能对内存进行读写,不能访问外设(输入或输出设备)

  2. 外设(输入或输出设备)要输入或者输出数据,也只能写入内存或者从内存中读取

  3. 所有设备都只能直接和内存打交道


  • 示例:登录上 qq 开始和某位朋友聊天的数据的流动过程


  1. 你的电脑:输入设备键盘将数据写到内存,内存再将数据给 CPU,CPU 得到结果再将数据写入内存,最后内存将数据刷新到网卡

  2. 朋友的电脑:输入设备网卡将数据写到内存,内存再将数据给 CPU,CPU 得到结果再将数据写入内存,最后内存将数据刷新到显示器上


  • 为什么运行程序必须先加载到内存:


这是即是冯诺依曼体系结构规定的,也是由于存储器分级的原因导致的


  • 示图:存储器层次结构



  1. 内存比较便宜速度慢,CPU 速度快但是贵,为了平衡速度与经济 CPU 一般不会太大,所以 CPU 不能直接存储数据

  2. 对于外设的输入输出效率会更慢,如果直接和 CPU 沟通会导致整个程序变得迟缓,所以由内存作为中间者和所有设备进行直接沟通

二、操作系统

  • 概念:


任何计算机系统都包含一个基本的程序集合,称为操作系统(OS)


  • 操作系统包括:


  1. 内核(进程管理,内存管理,文件管理,驱动管理)

  2. 其他程序(例如函数库, shell 程序等等)


  • 设计 OS 的目的:


  1. 与硬件交互,管理所有的软硬件资源

  2. 为用户程序(应用程序)提供一个良好的执行环境


注:OS 需要保护系统软硬件,所以它对任何用户都不信任,需要通过 OS 才能访问系统软硬件


  • 定位:


操作系统也被称作进行软硬件资源管理的软件


  • 如何理解 "管理":


  1. 操作系统作为管理者,主要做事情决策

  2. 而操作系统之下的驱动作为执行者,进行执行操作系统的决定

  3. 最后的底层硬件则是一个被管理的角色


  • 示图:



  • 怎么进行管理:


  1. 描述:先对被管理者进行描述,将其属性数据获取(数据写到 struct 结构体中)

  2. 组织:用链表或其他高效的数据结构进行管理数据(结构体),也就是对数据的操作达到管理的效果


  • 系统调用和库函数概念:


  1. 在开发角度,操作系统对外会表现为一个整体,但是会暴露自己的部分接口,供上层开发使用,这部分由操作系统提供的接口,叫做系统调用

  2. 系统调用在使用上功能比较基础,但对用户的要求相对也比较高,所以开发者对部分系统调用进行适度封装,从而形成库,利于更上层用户或者开发者进行二次开发

三、进程

  • 概念:


  1. 进程是程序的一个执行实例,从内核的角度上看进程是担当分配系统资源(CPU 时间,内存)的实体

  2. 即进程=程序+内核的 PCB

1、描述进程-PCB

  • 概念:


  1. 进程信息被放在一个叫做进程控制块的数据结构中,可以理解为进程属性的集合;在 Linux 中描述进程的结构体叫做 task_struct

  2. Linux 操作系统下的 PCB 是: task_struct-PCB 的一种,task_struct 是 Linux 内核的一种数据结构,它会被装载到 RAM(内存)里并且包含着进程的信息


  • task_ struct 内容分类:


标示符: 描述本进程的唯一标示符,用来区别其他进程 状态: 任务状态,退出代码,退出信号等优先级: 相对于其他进程的优先级程序计数器: 程序中即将被执行的下一条指令的地址内存指针: 包括程序代码和进程相关数据的指针,还有和其他进程共享的内存块的指针上下文数据: 进程执行时处理器的寄存器中的数据[休学例子,要加图CPU,寄存器//当多个程序需要同时被执行,而一个程序有执行的时间片,达到时间需要切换程序,切换到恢复的过程就需要上下文数据发挥作用,达到无缝切换的效果I/O状态信息: 包括显示的I/O请求,分配给进程的I/ O设备和被进程使用的文件列表记账信息: 可能包括处理器时间总和,使用的时钟数总和,时间限制,记账号等其他信息
复制代码


注:运行在系统里的进程都以 task_struct 链表的形式存在内核里

2、查看进程

  1. 进程的信息可以通过 /proc 系统文件夹查看


  • 示例:



  1. 大多数进程信息同样可以使用 top 和 ps 这些用户级工具来获取


  • 示例:



3、获取进程标示符

  • 系统调用函数:


  1. 使用 getpid()系统调用函数获取当前进程 id(PID)

  2. 使用 getppid()系统调用函数获取当前进程的父进程 id(PPID)


注:getpid()和 getppid()函数需要包含头文件 unistd.h


  • 示例:


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


  • 结果:


4、创建进程-fork()

  • fork()功能:


为当前进程创建子进程,父子进程代码共享,数据各自开辟空间私有一份(采用写时拷贝:进行写入时触发拷贝)


  • fork()返回值:


  1. 对于父进程,如果创建成功返回子进程的 pid,否则返回负数

  2. 对于子进程返回 0(成功创建)


  • 注意:


  1. 对子进程返回 0,是因为子进程只有一个父进程,可以直接找到对应父进程

  2. 对父进程返回子进程 pid 的意义是可以在父进程里直接得到子进程 ID(可能有多个子进程),对某个子进程进行操作和管理


注:fork 返回类型是 pid_t,需要包含头文件 sys/types.h


  • 示例:


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


  • 结果:



  • 父子进程分流执行:


我们创建子进程的意义是为了与父进程进行不同任务,因为父子进程的代码共享,所以我们采用分支结构进行分流执行程序


  • 示例:


#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;}
复制代码


  • 结果:



  • 为什么 ret 有两个返回值:


fork()函数在 return 的前一刻,其主体任务全部完成,也就是子进程成功创建,此时父子进程代码共享,数据各有一份(写时拷贝),在返回时发生写实拷贝,对于父进程的 ret 则是返回的子进程的 pid,对于子进程的 ret 则是返回的 0

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 */};
复制代码


  • 解释:


  1. R 运行状态(running):并不意味着进程一定在运行中,它表明进程要么是在运行中要么在运行队列里(可以被调度)

  2. S 睡眠状态(sleeping):意味着进程在等待事件完成(这里的睡眠有时候也叫做可中断睡眠,即浅睡眠)

  3. D 磁盘休眠状态(Disk sleep):有时候也叫不可中断睡眠状态,在这个状态的进程通常会等待 IO 的结束(不能被进程杀死,此外还包括僵尸进程)

  4. T 停止状态(stopped):可以通过发送 SIGSTOP 信号给进程来停止(T)进程,这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行

  5. X 死亡状态(dead):这个状态只是一个返回状态,你不会在任务列表里看到这个状态(非常快结束)

  6. t (tracing stop)状态:表示进程追踪状态,即进程在调试中停下来的一个状态(有些内核版本没有该状态)


  • 示图:



  • 查看状态指令基本格式及选项:


ps aux / ps axj :查看系统中所有的进程ps -la :查看基础进程a:显示一个终端的所有进程,除会话引线外u:显示进程的归属用户及内存的使用情况x:显示没有控制终端的进程-l:长格式显示更加详细的信息-e:显示所有进程
复制代码


  • 效果:


6、僵尸进程

  • 概念:


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

  2. 僵死进程会以终止状态保持在进程表中,并且会一直在等待父进程读取退出状态代码

  3. 即只要子进程退出,父进程还在运行,但父进程没有读取子进程状态,子进程进入 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)中,即一直不回收僵尸进程可能造成内存资源的浪费,直到被回收后才能释放其空间

7、孤儿进程

  • 概念:


父进程先退出,子进程就称之为“孤儿进程”,而孤儿进程会被 1 号 init 进程(系统)领养,最后由 init 进程回收


  • 示例:


#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;}
复制代码


  • 结果:


8、进程优先级

  • 概念:


  1. cpu 资源分配的先后顺序,就是指进程的优先权(priority),优先权高的进程有优先执行权利

  2. 配置进程优先权对多任务环境的 linux 很有用,可以改善系统性能

  3. 还可以把进程运行到指定的 CPU 上,以此可以大大改善系统整体性能


  • 权限和优先级的区别:


  1. 权限是能不能执行的问题

  2. 优先级是能执行,但是是先执行还是后执行

  3. 本身是因为资源有限,需要竞争获取资源,才提出优先级


  • 查看优先级:


使用 ps –l 命令


  • 示例:



  • 解释:


  1. UID : 代表执行者的身份

  2. PID : 代表这个进程的代号

  3. PPID :代表这个进程是由哪个进程发展衍生而来的,亦即父进程的代号

  4. PRI :代表这个进程可被执行的优先级,其值越小越早被执行

  5. NI :代表这个进程的 nice 值


  • PRI and NI:


  1. PRI 即进程的优先级,或者通俗点说就是程序被 CPU 执行的先后顺序,此值越小进程的优先级别越高

  2. NI 即 nice 值,其表示进程可被执行的优先级的修正数值

  3. 所以最终的优先级:PRI(new)=PRI(old)+nice

  4. 注:这里的 PRI(old)可以理解为一直是基准值 80

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

  6. 所以调整进程优先级,在 Linux 下就是调整进程 nice 值

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


  • PRI vs NI:


  1. 进程的 nice 值不是进程的优先级,但是进程 nice 值会影响到进程的优先级变化

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


  • 修改 nice 值:


先使用 top 命令,进入 top 后按“r”–>输入进程 PID–>输入 nice 值


  • 示例:



  • 为什么 PRI 要有基准值以及 NI 具有范围:


  1. 避免过高或者过低的优先级出现,保证可控并且竞争的相对公平,提高效率

  2. 便于运算,不用再读取优先级信息,并且实现简单


  • 进程退出 CPU 的可能:


  1. 优先级更高的进程抢占了 CPU

  2. 该进程时间片到了(多进程运行)


注:进程让出或者占领 CPU 资源时,就需要进行保存或者恢复进程的上下文数据


  • 其他概念:


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

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

  3. 并行: 多个进程在多个 CPU 下分别,同时进行运行,这称之为并行

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

9、环境变量

  • 概念:


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

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


  • 示例:


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


  • 常见环境变量:


  1. PATH : 指定命令的搜索路径

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

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


  • 查看环境变量:


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


  • 示例:


1)测试 PATH

注:以 PATH 为例,展现环境变量的作用


  • 示例:简单写个程序


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


  • 结果:



  • 引入:


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


  • 原因:


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

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


  • 示图:



注:其实程序,命令,指令,可执行程序等等都是一个概念


  • 如何将程序像指令一样执行(不带路径执行):


  1. 将我们的程序所在路径加入环境变量 PATH 当中


使用指令 export PATH=$PATH:path(程序所在路径)


  • 示例:



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


  1. 将程序拷贝到 PATH 变量中的某个路径中


  • 示例:


2)测试 HOME

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



  • 解释:


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


  • 和环境变量相关的命令:


  1. echo: 显示某个环境变量值

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

  3. env: 显示所有环境变量

  4. unset: 清除环境变量

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


  • 环境变量的组织方式:



  • 解释:


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

3)如何获取环境变量

  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;}
复制代码


  • 结果:



  1. 通过第三方变量 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 声明


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


  • 示例:


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


  • 结果:



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

4)命令行变量

  • 在命令行中,我们可以定义两种变量:


  1. 本地变量:只能够在当前 shell 命令行解释器内被访问,不能被子进程继承

​ 注:在命令行运行的指令,它的父进程都是 bash

  1. 环境变量:可以被子进程继承


  • 示例:



发布于: 刚刚阅读数: 4
用户头像

还未添加个人签名 2022-04-28 加入

还未添加个人简介

评论

发布
暂无评论
Linux系统-进程概念_Linux_可口也可樂_InfoQ写作社区