【Linux ——— 进程概念】了解操作系统 | 进程详解 | 进程状态 | 环境变量

已于 2024-06-24 08:16:51 修改
阅读量950 收藏 18
点赞数 9
文章标签： linux
于 2024-04-17 18:33:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55953229/article/details/137714892
版权

文章目录

前言

一、冯诺依曼体系结构

1.概念

我们日常生活中常见的计算机，像笔记本台式机，还有企业中用的服务器，大部分都遵守冯诺依曼体系结构。
在这里插入图片描述
至目前为止我们认识的计算机都是由一个个硬件组成的

  • 输入设备：鼠标，键盘，触摸板，摄像头，磁盘，网卡等。
  • 中央处理器(CPU)：控制器，运算单元等
  • 输出设备：显示器，打印机，磁盘，网卡等
  • 存储器：内存（磁盘和U盘一般指的是输入输出设备）

2. 了解硬件

中央处理器组件功能：
运算器：对我们的数据进行计算任务（算数运算，逻辑运算）
控制器：对我们的计算机硬件流程进行一定的控制。

内存:
CPU拿数据的话只能从内存中获取数据，不能直接从输入设备拿数据，且不能直接返回给输出设备。

原因：

“ 外设 ”(输入设备和输出设备)他们的存储效率太低了，会直接影响计算机整体性能.所以我们在CPU和外设中间添加了一个存储器。
内存的效率相比与外设的效率高了很多倍，和CPU的效率差不了太多，所以直接和CPU进行交互也不会太影响计算机整体的效率

由上，我们就可以理解一下几点
1.计算机的整体效率大部分是由内存决定的。
2.一个程序要运行起来，必须要先加载到内存中去，供CPU读取输出。
3.在C/C++的程序中，有些默认的数据不加“ \n ”刷新的话，可能会缓存起来。
原因：只是因为CPU在处理过代码之后是按照冯诺依曼体系结构先交给内存，当程序结束后才会刷新到显示器上，所以缓存是正常的。

3.微信或QQ聊天软件的聊天流程

在这里插入图片描述

3.1流程

1.首先我们要先把QQ/微信这个程序双击运行，加载到内存中。

2.通过输入设备【键盘】输入：“你好”，把你输入的消息先放到内存里，通过CPU对消息进行各种的打包计算，完成后再把数据写回内存，然后QQ/微信这款软件把数据发送到网卡中，同时给显示器也同步一份。

3.经过网络之后你发送的数据就到了对面的输入设备【网卡】再通过内存，到CPU这一流程对数据进行解包解压读取你发送的消息再写回内存中，再通过内存发送到对面的输出设备【显示器】上。

二、操作系统（Operator System）

1.操作系统定位

  • 在整个计算机软硬件架构中，操作系统的定位是：一款纯正的“搞管理”的软件（管理软硬件）

2. 设计操作系统的目的

  • 与硬件交互，管理所有的软硬件资源
  • 为应用程序提供一个良好的运行环境

3.为什么要有操作系统

操作系统通过帮助用户管理好，软硬件资源，为用户提供一个良好的运行环境。

不能让用户直接访问操作系统，同时也是为了计算机的安全，那样的风险太高了，所以操作系统提供了：系统调用接口

但是这些系统调用接口，用户需要访问必须要先有相应的操作系统知识，操作成本太高，而且还很容易操作失误。 所以很多人基于封装系统调用接口，创建了用户操作接口如shell外壳。

在这里插入图片描述
总结：

操作系统对下管理好软硬件资源
就是为了对上提供良好的运行环境

4.如何管理呢（先描述，再组织）

  1. 管理者和被管理者是不需要见面
  2. 管理者在不见被管理者的情况下，如何做好管理呢？只要能够得到管理信息，就可以在未来进行管理决策 —— 管理的本质： 是通过对 " 数据 "的管理，达到对人的管理。
  3. 管理者怎么能拿到数据呢？—— 通过执行者

所以管理者对被管理者的管理实际上是先描述被管理者的各种信息，然后将这些描述信息根据某种数据结构组织起来。管理者对被管理者的实际管理就是对这个数据结构的管理。

在操作系统中，管理任何对象，最终可以转化成为对某种数据结构的增删查改。

所以计算机管理我们底层的设备时，也是一样的再操作系统内部一个一个描述起来不同的设备。
每个设备都使用同样的结构体，结构体里不同的设备填上不同的属性值，构建出一个个属于这个设备对应的对象，然后再用算法（例如顺序表）连系起来，然后对设备的管理就变成了对操作系统内部对组织好的顺序表进行增删改查
总结：
计算机管理硬件流程：

  1. 描述起来，用struct结构体（因为操作系统是用C语言写的，所以只能用结构体来描述对象）
  2. 组织起来，用链表或其他高效的数据结构

5.系统调用和库函数概念

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

  • 系统调用在使用上，功能比较基础，对用户的要求相对也比较高，所以，有心的开发者可以对部分系统调用进行适度封装，从而形成库，有了库，就很有利于更上层用户或者开发者进行二次开发。

库函数：
例如我们在C语言中用到的printf函数想要打印出我们想要的信息，需要跟硬件交互，但是，我们不能直接找到硬件交互，只能贯穿整个【操作系统】。比如用fopen这样的想要访问硬件的函数，必须要通过操作系统。但是，操作系统不相信任何用户，只能通过系统调用接口访问，所以我们可以知道printf函数底层绝对是通过系统调用接口封装的。
所以C/C++中的库函数和系统调用是上下层的，调用和被调用的关系。

三、进程

1.进程概念

1.日常理解：一个已经被加载到内存中的程序，叫做进程
2.内核观点：担当分配系统资源（CPU时间，内存）的实体。

2.描述进程—— PCB

2.1 PCB概念
  • 进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
  • 课本上称之为PCB（process control block），Linux操作系统下的PCB是:task_struct
    一个操作系统不仅能运行一个进程，还能同时运行多个进程。操作系统必须要把进程管理起来。
    如何管理？先用struct把进程描述起来，再把进程组织起来。
    任何一个进程在加载到内存中时，操作系统首先要先创建描述进程的结构体对象——PCB——进程控制块
2.2 task_struct

task_struct是Linux内核的一种数据结构（自定义类型），它会被装载到RAM(内存)里并且包含着进程的信息。

struct task_struct
{
      //Linux控制块
}
2.3task_ struct内容分类
  • 标示符: 描述本进程的唯一标示符，用来区别其他进程。
  • 状态: 任务状态，退出代码，退出信号等。
  • 优先级: 相对于其他进程的优先级。
  • 程序计数器: 程序中即将被执行的下一条指令的地址。（在CPU中通常有一个寄存器记录当前正在执行进程的下一条指令的地址）
  • 内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
  • 上下文数据: 进程执行时处理器的寄存器中的数据[休学例子，要加图CPU，寄存器]。
  • I／O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
  • 记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等
  • 其他信息

3.进程理解

3.1先描述

在这里插入图片描述
我们在Linux环境下创建一个myprocess.c文件我们要运行它就要gcc myprocess.c -o myprocess生成一个可执行文件。
此时我们的文件时存在磁盘中，在我们./myprocess执行后就会把myprocess中的代码和数据加载到内存，**而且操作系统还为这当前的进程创建了一个PCB对象来描述维护我们的进程。**只有当程序对应的PCB和代码/数据都在内存中才能算进程。

由我们进一步的认知，所以现在我们再来谈一谈什么叫进程。

进程 = 内核PCB数据结构对像 + 你自己的代码和数据

内核PCB数据结构对象：描述你整个进程的所有属性值

进一步理解操作系统如何管理进程，只需要管理进程相对应的PCB数据结构，操作进程就能管理所有的操作进程。

3.2再组织

我们的操作系统中可能有很多个这样的进程，我们现在已经可以对每个进程进行管理。但是进程一多该怎么办呢？
我们可以在每个PCB中多加一个指针字段把这些PCB结构体串联起来。
这就被称为：再组织

在这里插入图片描述
Linux中是如何组织进程的？Linux内核中，最基本的组织进程task_struct的方式，是采用双向链表组织的

4.查看进程

在Linux中使用指令/proc可以查看当前所有进程。
这里面的数据在关机之后就全没了，开机之后操作系统会自动创建出来
这就是Linux操作系统用文件系统的方式，把内存中的信息和进程给我们可视化出来。
所以这里面的数据都是内存级别的数据。

且我们会发现
下图中包含了很多蓝色的数字，这些蓝色的数字都是目录，这些目录的数字就是当前进程的PID，所以只要一个程序运行起来变成进程，就会在proc目录下创建以该进程PID命名的目录或文件夹，保存了对应进程大部分属性。

在这里插入图片描述
比如我们看一下 “ 2168 ”PID对应的属性
在这里插入图片描述

但是我们日常一般使用一下几个指令

  1. ps：ps 命令是最基本和常用的进程查询命令。它可以显示当前终端下的进程信息。简单地键入 ps 就会显示当前用户的所有进程。
  2. ps aux：ps aux 命令显示了所有用户的所有进程的详细信息，包括进程的用户、PID、CPU 使用情况、内存使用情况等。一般配合grep查找关键字使用。
  3. top：top 命令提供了一个实时的系统进程监视功能，显示当前系统中运行的所有进程的动态信息。只需键入 top，你就会看到类似任务管理器的实时进程信息。

ps aux:
在这里插入图片描述
top:
在这里插入图片描述

5.进程PID/PPID详细了解

我们先创建一个.c文件，写上一个死循环，以便我们后面能够更好观察进程
在这里插入图片描述
执行起来之后我们输入指令

ps aux | head -1 && ps aux| grep proc

查看当前执行的进程proc（proc是我们上面写的死循环程序）
我们就能看到./proc进程对应的PID为27319。除了PID还有COMMAND，COMMAND运行时是执行了什么指令的。

在这里插入图片描述
我们在详细了解进程之前进程之前要先了解PID（进程）和PPID（父进程）

5.1 PID

我们的进程PID放在我们对应进程的task_struct中存放着
在这里插入图片描述
当我们的ps aux指令通过系统调用接口访问内存中的进程时，就是遍历双链表，把我们task_stuct中存放的各种属性拿出来，包括我们的pid属性。所以我们想要拿到pid的值就需要调用getpid();整个系统调用接口。
用法：
在这里插入图片描述
让我们执行起来：
所以我们可以看到我们当前进程的pid就是1563.
在这里插入图片描述

5.2 PPID

PPID（父进程） 是指创建当前进程的进程的 PID，在 Linux 中，每个进程都有一个父进程，除了初始进程（通常是 PID 1）。当父进程创建一个新的子进程时，子进程的 PPID 就会被设置为父进程的 PID。PPID 用于建立进程之间的父子关系。通过 PPID，可以追溯到进程的创建链条，即该进程是如何被创建的。

想要访问父子进程的PID都是需要用到系统调用接口的，父进程这里用到的是getppid()
在这里插入图片描述
在这里插入图片描述

当我们不停的重新运行程序我们会发现PID一直在变化，而PPID却不会发生改变，这种情况非常正常。
在这里插入图片描述
我们用PPID：32631来追根溯源来看看我们的PPID是什么
在这里插入图片描述
我们会发现PID为32631的进程是bash进程，

当我们运行一个进程时我们的命令行解释器会把我们当前程序变成bash的子进程，由子进程执行我们当前的命令。所以一旦我们的子进程出问题，并不会影响我们的bash进程。我们每次登录时系统都会为我们创建一个bash进程，所以bash进程的PID每次登录都会不一样。

四、通过系统调用创建进程——fork初识

1. 我们先用man fork认识一下fork

man fork

在这里插入图片描述
fork()创建一个新的进程，且是以我们调用的进程为模板，创建的一个新的进程。

fork返回值：成功的话会返回子进程的pid，且它会给子进程返回一个0，要是失败就返回-1。

我们通过下满代码来查看fork

	#include <stdio.h>
 18 #include <sys/types.h>
 19 #include <unistd.h>
 20 int main()
 21 {
 22 printf("begin：我是一个进程，pid：%d，ppid%d\n",getpid(),getppid());                      
 23     int ret = fork();
 24  if(ret < 0)
 25  {
 26     perror("fork");
 27     return 1;
 28  }
 29  else if(ret == 0)
 30  { //child
 		while(1);
 31     printf("我是子进程 : %d,ppid:%d\n", getpid(), getppid());
 32  }
 33  else
 34  { //father
 		while（1）;
 35     printf("我是父进程 : %d, ppid: %d\n", getpid(), getppid());
 36  }
 37     sleep(1);
 38     return 0;
 39 }

由以上代码执行出下面结果
在这里插入图片描述
我们就会发现我们的程序pid原本是19016，在fork后创建了两个进程，父进程就是19016进程它自己，且也为它创建了一个子进程。
在fork执行过后，会有两个执行流同时运行，一个是ret == 0的子进程，一个是ret > 0的父进程。他们会同时运行以上代码中两个while循环
在这里插入图片描述

2.所以fork具体干了什么呢？

在这里插入图片描述

当调用 fork() 函数时，操作系统会复制当前进程中PCB的所有属性内存内容（包括代码、数据、堆栈的地址等） 到新创建出的PCB的子进程空间中，把部分属性做一些修改（如把pid和ppid做一下修改）。并在新的子进程空间中执行相同的程序。这样，父进程和新创建的子进程会成为两个完全独立的进程，它们共享相同的代码和数据，但拥有不同的内存地址空间、当前进程 PID和父进程 PPID。
重点补充：
这里我们要知道，进程之间时具有独立性的，所以我们父子空间不能共享同一份数据，因为数据有可能被修改。而代码不能被修改，只需要被读取所以代码能 “ 共享 ” 。现在我们的子进程和父进程PCB指向的都是一样的代码和数据，当子进程一旦需要对【共享数据】进行修改时，操作系统会重现开辟一小块空间供子进程修改的数据存放。（用多少申请多少空间）这种技术就叫做父子进程数据层面的写时拷贝
在这里插入图片描述

当return语句返回时，因为父子进程共享了或者说指向了相同的代码，因为return也是代码，CPU调用父进程PCB时执行了一次return，CPU执行子进程时同样也会执行一次return，所以我们有了两次返回值。

五、进程状态

1. 操作系统进程状态

操作系统包含的状态主要有：运行、挂起、阻塞等。
在这里插入图片描述

在这里插入图片描述

创建态：我们要先知道CPU运行某一个进程要直接在struct runqueue（运行队列，由进程PCB组成的队列，此队列包含了队列头尾指针。）中寻找

运行态：即上图中所有处于运行队列中的进程都属于运行状态。（运行状态就是，已经准备好，随时可以被调度）

  1. 为了防止一个进程一直在执行，让其他进程不能执行的情况，每个进程都会有一个叫做：时间片的概念，每个进程中存放一个int time时间片记录运行时间，一般这个时间是10ms。过了10ms会切换到其他进程。
  2. 所以在一段时间内，所有的状态都会被执行，这种情况就叫做并发执行。（只有一个cpu时）

阻塞态：正在执行的进程由于某些事件（I/O请求，等待某个硬件，如键盘输入）而暂时无法运行，进程受到阻塞。在满足请求时进入就绪状态等待系统调用。阻塞会占用内存资源。

挂起态：当操作系统内部的内存严重不足时，会保留一些空闲没有或者是没有被调度的进程的PCB，然后把代码和数据放入相应硬件中（如硬盘），此时改进程代码和数据并没有在内存中，这种状态就被称为 “ 阻塞挂起状态 ”。

2.具体Linux进程状态

2.1 先来看一下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））例如bash，bash进程当没有在命令行输入数据时，就是等待状态。
  • D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态/深度睡眠（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。
  • T停止状态（stopped）： 可以通过发送 SIGSTOP 信号（19号信号）给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。T状态是完全暂停，除了被单独接受信号才能继续进行。
  • X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态.
2.2进程状态查看
ps aux / ps ajx //通过这两个命令查看进程

在这里插入图片描述

2.3 僵尸状态（zombie）
  • 僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程
    没有读取到子进程退出的返回代码时就会产生僵尸进程
  • 僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。
  • 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

来一个创建维持15秒的僵死进程例子：

1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include<unistd.h>
  4 #include<sys/types.h>
  5 int main()
  6 {
  7     pid_t id = fork();
  8     if (id < 0)
  9     {
 10         perror("fork");
 11         return 1;
 12     }
 13     else if(id > 0)
 14     {
 15         //父进程
 16         printf("parent[%d] is sleeping...\n",getpid());
 17         sleep(15);
 18     }
 19     else
 20     {
 21         //子进程
 22         printf("child[%d] is begin Z...",getpid());
 23         sleep(5);
 24         exit(EXIT_SUCCESS);
 25     }
 26     return 0;
 27 }

我们可以看到当五秒过后myproc子进程就变成了Z状态，且我们看最后一行变成Z状态的子进程多了一个后缀【defunct】“失效的”，它在等待父进程接受它的返回值。在Z状态时进程的相关资源（task_struct）结构体不能被释放！。

所以僵尸进程会被一直占用，这就形成了内存泄漏

在这里插入图片描述

在这里插入图片描述

3.孤儿进程

3.1概念

当我们的fork出父子进程时，如果我们的父进程比子进程先推出，这样的的情况，子进程就被称为 “ 孤儿进程 ”。

3.2实现

我们看一下代码


  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include<unistd.h>
  4 #include<sys/types.h>
  5 int main()
  6 {
  7     pid_t id = fork();
  8     if (id < 0)
  9     {
 10         perror("fork");
 11         return 1;
 12     }
			 if(id == 0)
 28     {
 29         int cnt = 500;
 30         while(cnt)
 31         {
 32             printf("I am child,pid:%d,ppif%d,cnt%d\n",getpid(),getppid(),    cnt);
 33             cnt--;
 34             sleep(1);
 35         }
 36         
 37     }
 38     else
 39     {
 40         int cnt = 5;
 41         while(cnt)
 42         {
 43         printf("I am parent,pid:%d,ppif%d,cnt%d\n",getpid(),getppid(),cnt    );
 44         cnt--;
 45         sleep(1);                                                        
 46         }
 47 
 48     }
 49     return 0;
 50 }

在这里插入图片描述
当我们的父进程运行5秒后由bash回收父进程，现在的子进程就没有了父进程，成为了孤儿进程。但我们会发现现在的子进程ppid是1。进程1init是什么呢？是操作系统。

4.进程优先级

4.1 基本概念
  • cpu资源分配的先后顺序，就是指进程的优先权（priority）。
  • 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。
  • 还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能。
4.2查看系统进程属性

在Linux或unix环境下，在指令行输入ps -l 会输出一下内容。
在这里插入图片描述
它上面的属性代表什么呢？

  • UID : 代表执行者的身份
  • PID : 代表这个进程的代号
  • PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
  • PRI ：代表这个进程可被执行的优先级，其值越小越早被执行
  • NI ：代表这个进程的nice值

PRI and NI

  • PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高
  • 那NI，就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值，nice其取值范围是-20至19，一共40个级别。
  • PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice
  • 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行
  • 所以，调整进程优先级，在Linux下，就是调整进程nice值

PRI vs NI

  • 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进
    程的优先级变化。
  • 可以理解nice值是进程优先级的修正修正数据

5.查看进程优先级的命令

5.1top命令修改nice以调整优先级

为什么要有优先级：
因为资源是有限的，进程是多个的，注定了进程之间是竞争关系！
操作系统必须保证大家良性竞争，确认优先级。

top->按"r"建->输入PID值，回车->输入调整的大小

在这里插入图片描述
在调整10nice值后我们可以看到优先级数字变成了90.
在这里插入图片描述

注意：优先级数字越低越优先，所以我们想要把优先级往下调的话需要调用sudo权限。

补充概念

  • 竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级
  • 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰
  • 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行
  • 并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发

进程切换

进程在被切换时：

  1. 需要保存上下文
  2. 恢复上下文

上下文数据：cpu寄存器内，保存的是进程的临时数据，（或者说cpu内关于进程的所有数据）这就叫做进程的上下文数据。 且进程在cpu上离开时，要将自己的上下文数据保存好，甚至带走。（目的是为了将来恢复）
上下文数据保存在哪里呢？能保存在进程自己的PCB内。

六、环境变量

1.基本概念

  • 环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数
  • 如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
  • 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性

2.常见环境变量

  • PATH : 系统指定命令的搜索路径
  • HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)
  • SHELL : 当前Shell,它的值通常是/bin/bash。

3.查看环境变量方法

echo $NAME //NAME是环境变量的名称

在这里插入图片描述
补充：PATH路径是使用”：“作为分隔符

4.测试PATH

我们在日常使用Linux系统时会发现，生成了一个可执行程序如：myproc
我们只能用./myproc才能把该程序执行起来
但是我们使用的日常指令操作如：pwd，不用”./“（或者说不用指定路径）就能执行起来。为什么呢？
我们来用which来对pwd执行一下
在这里插入图片描述
我们可以观察到/usr/bin这个目录在我们上文查看PATH路径时，PATH路径中也包含由相同路径。

因为系统当中对于指令的搜索，我们的Linux操作系统会为我们提供一个环境变量，专门在这个环境变量内的地址内查找匹配的指令，PATH就是这个环境变量
所以只要我们的myproc程序当前所处的路径包含在这个PATH路径下，我们也能实现不用指定路径就直接执行可执行程序的操作。

那么该怎么包含呢？

PATH=$PATH:/home/goat/test/linux/exercise/2024-4-15test(你的程序所处的路径)
 // 加上 " $PATH: " 这就算是在原本PATH的基础上额外包含了我们自己程序的路径

包含过后PATH路径就有了我们自己程序所处的路径。
在这里插入图片描述
我们现在直接执行即可。
在这里插入图片描述

5.测试HOME

任何一个用户在运行系统登录时都有自己的主工作目录（家目录），环境变量HOME当中即保存的该用户的主工作目录。
root用户：
在这里插入图片描述

其他用户：
在这里插入图片描述

6.测试SHELL

为什么我们默认所处的目录时处于我们的家目录，这是为什么呢。
这是因为我们每次登录时，我们的SHELL都会识别到这次登录的账户是谁，然后给我们填充$HOME这样的环境变量。也会给我们分配命令航解释器，类似于直接给我们cd $HOME到默认家/工作路径。
在这里插入图片描述

环境变量相关命令

  1. echo：显示某个环境变量的值。
  2. export：设置一个新的环境变量。
  3. env：显示所有的环境变量。
  4. set：显示本地定义的shell变量和环境变量。
  5. unset：清除环境变量。

env查看所有环境变量
在这里插入图片描述

7.getenv

我们也能通过系统函数调用接口访问我们的环境变量

getenv("环境变量名");

在这里插入图片描述

在这里插入图片描述

7、环境变量的组织方式

在系统当中，环境变量的组织方式如下。
在这里插入图片描述

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

8.通过代码如何获取环境变量

1.我们现在来重新认识运行main函数，main函数其实一直是有参数的。

在这里插入图片描述

  1. argc:argc是个整数表示的是，传递命令行参数的个数，且包括程序名，所以argc的值至少为1。
  2. argv[ ]：argv是一个指针数组，里面包含了命令行参数，如：”ls“，”-a“，”-b“。
  3. env[ ]：env是一个指向环境变量的指针数组。

我们先来对一下argv[]参数进行演示：
在这里插入图片描述

下图中就是，argc存的是./test -o -u -t参数的个数，argv存的就是分别指向这四个参数的指针。

在这里插入图片描述

然后我们再来看env[]
在这里插入图片描述
所以我们的程序变成进程的时候，也就是我们的main执行的时候会自动带有系统环境变量
在这里插入图片描述
到这里我们会觉得这些环境变量是否有些眼熟，好像就是我们上文里【用env查看全部环境变量】里面的环境变量好像和我们main函数里env[]的环境变量一样。
这里我们就要说到我们在shell里执行./执行的程序，是我们bash进程的子进程。也就是说，我们所运行的进程都是子进程，bash本身在启动的时候，会在操作系统配置文件中读取环境配置信息。bash本身会在自己的上下文里，帮我们构建一张环境变量表。如果子进程需要的话，bash就会把自己的环境变量配置信息给子进程一份。
所以子进程会继承父进程交给它的全部环境变量配置信息。

2.environ获取环境变量

在这里插入图片描述
结果
在这里插入图片描述
注意：libc中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时要用extern声明。

9.本地变量

1.概念

本地变量，只会在BASH内有效，不会被继承。

2.格式

在这里插入图片描述
我们直接在命令行像上图方式定义变量，就是本地变量

这时我们会发现一个问题，用env的方式查找我们定义的本地变量会查找不到
命令行env | grep local查找不到名为local的环境变量
在这里插入图片描述
这里要在命令行使用set命令，可以查到系统当中定义的所有变量，包括本地变量和环境变量
在这里插入图片描述

补充知识：常规和内键命令

  1. 常规命令：通过创建子进程完成的
  2. 内键命令：bash不创建子进程，而是由自己亲自执行。（bash调用自己写的或系统提供的函数）
goat¢
关注
  • 9
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
[进程]进程的状态转换
超越
04-28 4234
进程的三态模型 按进程在执行过程中的不同情况至少要定义三种状态： 运行（running）态：进程占有处理器正在运行的状态。 进程已获得CPU，其程序正在执行。在单处理机系统中，只有一个进程处于执行状态； 在多处理机系统中，则有多个进程处于执行状态。 就绪（ready）态：进程具备运行条件，等待系统分配处理器以便运行的状态。 当进程已分配到除CPU以外的所有...
操作系统——进程状态
qq_58264156的博客
10-15 1336
版权声明：本文为CSDN博主「_好好学习」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/jay_zzs/article/details/113192123进程从创建到执行，再到执行完毕销毁的过程中，经历了不同的，进程状态部分取决于进程当前的活动，可以将进程状态分为；；。
【操作系统】-三种进程状态
最新发布
weixin_65728773的博客
04-09 284
阻塞（blocked）在阻塞状态下，一个进程执行了某种操作，直到发生其他事件时才会准备运行。应该常见的例子是，当进程向磁盘发起I/O请求时，它会被阻塞，因此其他进程可以使用处理器。就绪（ready）在就绪状态下，进程已准备好运行，但由于某种原因，操作系统选择不在此时执行。运行（running）在运行状态下，进程正在处理机上处理，意味着正在执行。
Linux操作系统~进程有哪些状态？
Zebra的博客
11-04 4657
D状态是一种不可中断的睡眠状态。比如一个进程让磁盘你帮我写1G数据到磁盘里面去，磁盘开始忙了，进程就会进入D状态等待磁盘写入完成（因为这种等待状态是不允许被中断的，因为如果中断进程的等待，磁盘写入数据完成后，无法向原来的进程返回错误/正确信息，会导致一些问题）D状态就是深度睡眠，处于这种状态的进程不能被中断的（不可以被杀掉）进程在内核中某些不能被信号打断，例如对某些硬件设备进行操作时刻（等待磁盘Io,等待网络io等等）。进程处于D状态一般情况下很短暂，不应该被top或者ps看到。
进程的三大状态以及转换
sinat_24520925的专栏
03-26 1226
第一部分： 1.进程的三种基本状态 进程在运行中不断地改变其运行状态。通常，一个运行进程必须具有以下三种基本状态。 （1）就绪(Ready)状态 当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。 （2）执行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。 （3）阻塞
Linux进程控制详解及实例
09-15
Linux进程控制是操作系统的核心组成部分，它允许用户和系统创建、管理以及终止进程。在这个主题中，我们将深入探讨几个关键的Linux进程控制函数，包括fork()、exec家族、wait()和exit()，并提供实例来解释它们如何...
疯狂内核之——进程管理子系统
05-30
1.1.2 进程状态 10 1.1.3 TASK_RUNNING状态的进程链表 11 1.1.4 进程间关系 12 1.2 Linux的线程——轻量级进程 15 1.3 进程的创建——do_fork()函数详解 19 1.4 执行进程间切换 33 1.4.1 进程切换之前的工作 33 ...
[Linux命令详解词典]
01-18
《Linux命令详解词典》是由施威铭研究室编著的一本详尽解析Linux命令的参考书籍，旨在帮助用户深入理解和掌握Linux操作系统中的各种命令。这本书以扫描版的形式提供，包含PDF格式，方便读者在线阅读或下载。标签...
Linux菜鸟过关+Linux程序指南+Linux系统命令及使用详解
03-05
在IT领域，Linux操作系统是不可或缺的一部分，尤其对于程序员和系统管理员而言，掌握Linux技能至关重要。本文将基于"Linux菜鸟过关+Linux程序指南+Linux系统命令及使用详解"的主题，深入探讨Linux的基础知识、常用...
cmd操作命令和linux命令大全收集
04-24
CMD命令：开始－>运行－>键入cmd或command（在命令行里可以看到系统版本、文件系统版本） 命令大全 1. gpedit.msc-----组策略 ...set 指定环境变量名称=要指派给变量的字符 设置环境变量 set 显示当前所有的环境变量...
深入理解操作系统原理之进程管理（一）
想作会飞的鱼的博客
06-27 2万+
一、概述 1、为什么引入进程 程序并发执行时具有如下特征： 间断性 程序在并发执行时，由于它们共享资源或为完成同一项任务而相互合作，使在并发程序之间形成了相互制约的关系。相互制约将导致并发程序具有“执行-暂停-执行”这种间断性活动规律。 失去封闭性 程序在并发执行时，是多个程序共享系统中的各种资源，因而这些资源的状态将由多个程序来改变，致使程序的运行已失去了封闭性。 不可再现性
操作系统-进程状态转换图
sofia_fhx的博客
03-23 4万+
为什么要分开就绪和阻塞状态 答：因为就绪态只需要等待处理机，而阻塞态可能在等待输入输出，即使分配给处理机也是徒劳，所以两状态图不妥。对于调度进程，只需要等待就绪队列里的进程，因为阻塞状态可以转换到就绪队列里去。 进程五状态 新状态：进程已经创建，但未被OS接纳为可执行进程。（还没有申请到相应的资源）。 就绪态：进程做好了准备，准备执行（只等待处理机）。 执行状态：该进程正...
三状态进程模型
wj1187245816的博客
11-27 3832
很容易想到，一个进程可以处于两种状态：运行态和非运行态。在非运行态中，有的进程在等待某些事件完成（如：I/O设备）后才能执行，称为阻塞或等待态，有的进程运行条件都已经满足，只差 CPU 资源就可以运行，称为就绪态。因此我们引入三状态进程模型。 三状态进程模型 　　　　　　　　　　　　　　图1：三状态模型 运行态：进程正在运行。非运行态：a. 就绪态：进程获得了除处理器以外所有运行
操作系统：进程的三种状态
五山口老法师
01-17 1万+
进程的三种状态 1.   就绪状态：进程获得了除了CPU之外的所有的必要资源，只要获得CPU就可以立即执行，此时的进程处于就绪态。 2.   运行状态：进程已经获得CPU，正在运行，在多处理其系统中，会有多个进程同时处于运行状态。 3.   阻塞状态：处于执行状态的进程由于发生某些事件而暂时无法继续执行，放弃处理机而处于暂停状态，此时进程就处于阻塞（执行受到阻塞）状态。 进程的三种状态之间...
进程的五种基本状态 - 操作系统
热门推荐
听雨居
11-05 6万+
创建状态：进程在创建时需要申请一个空白PCB，向其中填写控制和管理进程的信息，完成资源分配。如果创建工作无法完成，比如资源无法满足，就无法被调度运行，把此时进程所处状态称为创建状态就绪状态：进程已经准备好，已分配到所需资源，只要分配到CPU就能够立即运行执行状态：进程处于就绪状态被调度后，进程进入执行状态阻塞状态：正在执行的进程由于某些事件（I/O请求，申请缓存区失败）而暂时无法运行，进程受到阻塞。
操作系统与进程的状态
梦里蓝天
05-24 1581
操作系统的定义 操作系统（Operating System，OS）是计算机系统中的核心系统软件，负责管理和控制计算机系统中的硬件和软件资源，合理地组织计算机工作流程和有效地利用资源，在计算机与用户之间起接口的作用。操作系统为用户提供的接口表现形式一般为：命令、菜单、窗口之类的，而操作系统为应用程序提供的接口为 API。 操作系统的分类 按照操作系统的功能划分，操作系统的基本类型有批处理操作系统、分时操作系统、实时操作系统、网络操作系统、分布式操作系统、嵌入式操作系统、微内核操作系统等。 操作系统的主要工作
「操作系统」进程状态模型
Nxin的小抄本
05-19 4785
进程由程序代码, 相关数据集与进程控制块(Process control block, 简称PCB)所构成. 当处理器开始执行这段代码时, 我们将执行的实体称为进程, 即计算机中已运行的程序. 与进程相关的一些控制信息都保存在进程控制块中, 进程控制块是操作系统支持多进程的关键. 进程控制块中的状态字段用于记录进程目前所处的状态. 进程派生即在一个进程中创建一个新进程, 原先的进程为父进程, 新进程为子进程.
操作系统的进程状态变迁图_操作系统 - 进程的概念
weixin_39732825的博客
12-03 1175
在讨论操作系统时，总是出现的一个问题涉及如何调用所有CPU活动。早期的计算机是执行作业jobs的批处理系统，随后出现了运行用户程序user programs或任务tasks的分时系统。即使在单用户系统上，用户也可以一次运行多个程序：文字处理器，Web浏览器和电子邮件包。而且即使计算机一次只能执行一个程序，例如在不支持多任务的嵌入式设备上，操作系统也可能需要支持其自己的内部编程活动，例如内存管理。在...
计算机操作系统第章(“进程”文档)共152张.pptx
11-14
计算机操作系统第章(“进程”文档)共152张.pptx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值