【Linux】进程优先级 + 环境变量

📖 前言

在学完进程状态之后，本章我们将来学习一下环境变量，还有进程优先级等🙋🙋🙋……

本文实验系统：CentOS 7.6~

---

1. 进程优先级

1.1 什么是优先级：

• 优先级是权限吗？

在之前我们讲解过什么是权限：👉 传送门

我们这里讲的优先级并不是权限，那么优先级到底是什么呢？

• 如果我们说权限是能不能的问题的话
• 那么优先级就是 — 能！但只不过是先还是后的问题
• 优先级是进程获取资源的先后顺序

• 为什么会存在优先级？

• 排队的本质叫做确认优先级
• 那么排队的最根本原因是 — 资源不够！

系统里面永远都是，进程占大多数，而资源是少数！所以，进程竞争资源是常态！一定需要确认先后！

Linux下的优先级的相关概念和操作（怎么办）：

• Linux优先级的构成：

• priority + nice

我们可以根据自己的需求将进程的优先级进行修改：

• 要更改进程优先级，需要更改不是pri，而是NI
• nice：进程优先级的修正数据！

数字越小，代表优先级越高，数字越大，代表优先级越低。

1.2 如何修改优先级：

我们可以通过代码的方式来对优先级进行修改，但是我们只讲通过修改nice的方式来对进程优先级进行修改。

注意：

• 虽然我们可以对Linux进程的优先级进行修改
• 但是Linux不允许进程无节制的设置优先级

不建议随便改Liunx系统中的优先级，因为我们并不懂调度器的调度算法，随便的更改优先级就是变相的插队，可能让我们自己写的进程优先得到了某种资源，但是可能会打破调度系统的平衡。

每次设置优先级，这个old优先级都会被恢复成为80。

• 修改方式：

• top + r：改优先级。

一个进程的优先级不能被轻易修改，会打破调度器平衡，如果非得设置就必须具备超级用户的权限。

nice值的修改并不是无节制的，是有一定取值范围的：

• nice [-20, 19]
• prio [60，99]

如果nice修改的值超出了指定的修改范围，那么就会取其上、下限。

当我们设置完该进程的pri为60之后，再次对该进程的nice进行修改，此时pri会再次恢复到80！！

• prio = prio_old + nice

---

2. 进程的其他概念

2.1 竞争性与独立性：

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

进程在使用资源的时候是不允许别的进程来使用的。竞争方式一：排队。

当一个进程在使用资源的时候,是不允许别的进程也来使用该资源的基本上所有的外设和CPU都是这样子的。

独立性： 多进程运行，需要独享各种资源，多进程运行期间互不干扰，进程运行是有独立性的。

进程运行具有独立性，不会因为一个进程挂掉或者异常，而导致其他进程出现问题！

使用STL将对象放到各种容器中，就像在Linux系统当中将PCB放来放去是一个道理。

2.2 并行与并发：

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

我的电脑是单CPU的，但是我的电脑中有各种进程都可以在跑，这是什么原因？

此时我们不得不清楚一个概念：

多个进程都在你的系统中运行 != 多个进程都在你的系统中同时运行

• 不要以为进程一旦占有CPU， 就会一直执行到结束，才会释放CPU资源！
• 我们遇到的大部分操作系统都是分时的！
  
  操作系统会给每一个进程，在一次调度周期中，赋予一个时间片的概念！
• 在一个时间段内，多个进程都会通过切换交叉的方式，让多个进程代码，在一段时间内都得到推进
• 例如一个进程只能在CPU上执行10ms就要从CPU上扒下来，让其他的进程来执行
• 这种现象，我们叫做并发！

这就是跑死循环不卡死的原因，可能会卡一点，因为存在进程的切换。

操作系统中的一个软件叫调度器帮我们做的将进程放在CPU再扒下来，赋予执行的时长，为什么是这么长时间等等…

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

如果存在多个CPU的情况，在任何一个时刻，都有可能有两个进程在同时被运行（就是在CPU上运行）

2.3 进程间优先级的体现：

操作系统，就是简单的根据队列来进行先后调度的吗？？有没有可能突然来了一个优先级更高的进程？？

当代计算机都具有的一种机制：抢占式内核！

正在运行的低优先级进程，但如果来个优先级更高的进程，我们的调度器会直接把进程从CPU上剥离，放上优先级更高的进程，进程抢占。

进程抢占：

有可能进程正在跑，突然来了个优先级更高的进程，操作系统直接就把这个进程扒下来了，让优先级更高的进程来跑。

2.4 O(1) 调度算法：

这里我们就简单介绍一下：

• 允许不同优先级的进程存在
• 相同优先级的进程，是可能存在多个的！

而我们之前学习过数据结构，我们知道队列是先进先出的，是不允许随意插入的，那么优先级如何体现出来呢？

操作系统采用的是哈希的数据结构，哈希复习：传送门

根据不同的优先级，将特定的进程放入不同的队列中！

同时操作系统还做了另外的结构优化，因为存在大量不同优先级的进程，如果遍历哈希表的话就是线性探测，这里则是运用位图来判断所需进程在不在，位图复习：传送门

操作系统会把活跃的进程放在一起，旧的进程放在一起，最后再交换指向两个哈希表的指针，就将两个哈希表交换了。

• swap(active, old) ;

2.4 进程上下文：

CPU一定具有把数据暂时保存起来的能力。
CPU内的寄存器更多是用来保存一些临时数据。
CPU内的寄存器是：可以临时的存储数据，非常少，但是非常重要。

int func()
{
	int a = 10 + 20;

	return a;
}

int main()
{
	int ret = func();

	return 0;
}

把a的值放到了寄存器eax里面，用寄存器的方式来充当返回值，把寄存器里面的值mv到ret变量里，也就是把数据从CPU放到了内存里面。

• 当进程再被执行的过程中，一定会存在大量的临时数据，会暂存在CPU内的寄存器中！

我们把进程在运行中产生的各种寄存器数据，我们叫做进程的硬件上下文数据。

• 当进程被剥离：需要保存上下文数据
• 当进程恢复的时候：需要将曾经保存的上下文数据恢复到寄存器中

上下文在哪里保存呢？—— task struct

3. 环境变量

3.1 环境变量的概念：

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

环境变量的用途：

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

我们之前学习的各种指令，工具，和可执行文件：

• 都是可执行程序，我们可以将自己写的可执行程序叫指令，系统的指令叫命令程序二进制文件
• 其实大家都可以既叫做指令，又叫做工具, 又叫做可执行程序，都可以
• 其实是一码事…

3.2 查看环境变量：

Linux查看环境变量的方法：

• 而我们自己写的可执行程序为什么要带上路径才能执行，而系统中的命令则是不需要带路径？？

• 系统中是存在相关的环境变量，保存了程序的搜索路径的！
• 系统中搜索可执行程序的环境变量叫做PATH！

解释：

环境变量PATH里面有多种变量，中间用冒号:分割开，其中我们在执行某个程序时：例如在执行Is时， 当识别到有Is输入时， 会在上面的路径中一个一个的搜索，只要在特定路径下找到了Is，就会执行特定路径下的Is，执行完就停止搜索不再往后走了，换言之PATH就提供了可执行程序搜索的路径。Is或者是很多指令在PATH里面是可以被找到的。

那我们自己写的程序，生成的可执行程序之后，我们也想不通过带路径的方式像指令一样执行它，我们有两种方式：

3.3 修改环境变量：

直接mytest当做指令用，直接将可执行程序执行起来，不带路径：

方法一：直接将可执行程序拷贝到系统当中

一开始不做任何处理：


不建议自己安装，更不建议将自己的指令拷贝到Linux系统的目录下，因为会污染Linux系统的命令池。

第二种：将mytest的所处路径也添加到环境变量里

命令行变量分两种:

1. 普通变量
2. 环境变重(全局)

定义变量可不仅仅只能在C/C++中，Linux命令行或者系统中也是可以直接定义变量的。

但是定义的是普通变量，通过查看环境变量的方式查看不了。

export导出环境变量，就可以在系统中可以查看的环境变量。

所以我们就可以通过export将环境变量中的PATH给改了，就可以实现不用路径直接执行可执行程序了。

但是不能通过上述方式，因为这样改的话就将全部的PATH给改了，那么其他的指令也就用不成了。

不过我们也不用过于担心，我们在命令行上设置的环境变量具有临时性的，将终端关掉重启就恢复了。

环境变量本身就在内存中存着呢，并不是以文件的方式存在的，改了也不影响，下次登录的时候会重新读取系统的配置文件，重新生成环境变量，如果想让配置的环境变量永久有效的话，是需要更改配置文件的。

• 登录程序会自动执行Linux上的程序，帮我们在bash的上下文当中导出一些变量，这些变量是从文件中来的。
• 可以理解成，就相当于在启动的时候读取配置文件，跟我们写程序一样，将数据读到内存里，然后在内存里env就能查看到对应的环境变量了。

系统中相关配置文件一般在：

正确修改环境变量：

备注：

环境变量轻易不要修改，非要改最好是新增，不要做覆盖。

which是通过环境变量来查找可执行程序的路径。

3.4 和环境变量相关的命令：

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

前几个我们已经讲的差不多了，我们来介绍后几个：

• unset：

• set：

aa叫局部变量查不到，可以通过export直接倒成环境变量，此时再查就能查到了。

查看本地变量：

set的环境变量和本地变量都能查到。

3.5 环境变量的获取：

3.5 - 1 main函数可以带参数吗？可以带多少？

我们先来看main函数带两个参数：

#include <stdio.h>

int main(int argc, char* argv[]) 
{
    int i = 0;
    for(i = 0; i < argc; i++)
    {
        printf("argv[%d]: %s\n", i, argv[i]);
    }
    return 0;
}

将命令行传递给命令行参数：

• char* argv[]是个指针数组，而int argc则是指针数组中元素的个数。
• 可执行程序和选项都是字符串，最后都以指针数组的方案存在了指针数组中。
• 指针数组中存的是字符串的起始地址
• 最后以NULL结尾

我们给main函数传递的argc，char* argv[]是命令行参数，传递的是：命令行中输入的程序名和选项！！

具体是哪个字符串的起始地址呢？

这样就传递命令行参数了。

3.5 - 2 传递参数的意义是什么

命令行计算器：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    if(argc != 4)
    {
        printf("Usage: %s [-a|-s|-m|-d] one_data two_data\n", argv[0]);
        return 0;
    }

    int x = atoi(argv[2]);
    int y = atoi(argv[3]);

    if(strcmp("-a", argv[1]) == 0)
    {
        printf("%d+%d=%d\n",x, y, x + y);
    }
    else if(strcmp("-s", argv[1]) == 0)
    {
        printf("%d-%d=%d\n",x, y, x - y);
    }
    else if(strcmp("-m", argv[1]) == 0)
    {
        printf("%d*%d=%d\n",x, y, x * y);
    }
    else if(strcmp("-d", argv[1]) == 0 && y != 0)
    {
        printf("%d/%d=%d\n",x, y, x / y);
    }
    else
    {
        printf("Usage: %s [-a|-s|-m|-d] one_data two_data\n", argv[0]);
    }

    return 0;
}

运行结果：

意义：

• 同一个程序，通过传递不同的参数，让同一个程序有不同的执行逻辑，执行结果。
• Linux系统中，会根据不通的选项，让不同的命令，可以有不同的表现！指令中那么多选项的由来和起作用的方式！！
• ls -a -l -i不同的选项代表的含义不一样。

那么命令行参数是怎么传递给main函数的呢？？

• 进程控制讲

3.6 进程获取环境变量的方法：

方法一：main函数的第三个参数

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

void func(void)
{
    printf("hehe\n");
}

int main(int argc, char* argv[], char* env[])
{
    //func(1, 1);
    int i = 0;
    for(i = 0; env[i]; i++)
    {
        printf("env[%d]: %s\n", i, env[i]);
    }

    return 0;
}

打印出来的就是各种环境变量了：

• char* env[]也是个指针数组
• 数组里的每个元素都是指向一个字符串
• 每个字符串就是一个环境变量
• 最后以NULL结尾

一个进程是会被传入环境变量参数的，每个进程都是的！！

我们自己的程序跑起来变成进程，这个进程就被调用方传入了环境变量了。

如果一个C语言函数在声明中没有带参数，但是我们强制给其带参的话并不报错。
而且强行传的参数，依旧压栈，依旧形成临时变量，只不过后面没有使用罢了。
给函数定义的时候形参带上void的话，强制传参才会报错。

进程想获得环境变量的第一种方法，那就是main函数的第三个参数，传进来的值就是一个指针数组，就可以通过指针数组的方案来遍历。

方法二：通过C语言内部维护的environ

int main()
{
	extern char** environ;

	for (int i = 0; environ[i]; i++)
	{
		printf("%d: %s\n", i, environ[i]);
	}

	return 0;
}

方法三：用接口getenv()

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char* val = getenv("PATH");
    printf("%s\n", val);

    return 0;
}

3.7 我为什么要获取环境变量：

以后有用途，万一有用途~

我们写一个只能自己运行的程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    //让程序只能自己执行
    char* id = getenv("USER");

    //忽略大小写
    if(strcasecmp(id, "Zh_Ser") != 0)
    {
        printf("权限拒绝!\n");
        return 0;
    }
    printf("成功执行...\n");

    char *val = getenv("PATH");
    printf("%s\n", val);
    
    return 0;
}

就算是root用户也不能执行！

环境变量是谁给我的呢？？目前谈不清，但是我们可以观察到！