最新Linux--进程概念_gid是进程(2)

最新推荐文章于 2024-06-14 14:37:55 发布

2401_83621603

最新推荐文章于 2024-06-14 14:37:55 发布

阅读量338

点赞数 5

分类专栏：程序员文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/2401_83621603/article/details/138391968

版权

程序员专栏收录该内容

133 篇文章 1 订阅

订阅专栏

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;
}

进程状态

宏观概念

总结：

1.一个CPU一个运行队列

2.让进程入队列的本质是：将该进程的struct stsk_struct结构体对象放入运行队列中

3.进程PCB在runqueue，就是R–运行状态，而不是这个进程正在运行才叫运行状态

4.进程不只会等待（占用）CPU资源，也可能随时随地要外设资源

5.所谓的进程不同的状态，本质是进程在不同的队列中，等待某种资源

挂起状态

阻塞和挂起的区别

挂起了一定阻塞，阻塞了不一定挂起。阻塞时该进程的代码和数据都在内存中，当内存不足时，就会产生挂起状态该内存的数据和代码就会被操作系统放进磁盘中

Linux操作系统的的状态

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）：**这个状态只是一个返回状态，你不会在任务列表里看到这个状态。

进程状态查看

ps aux / ps axj 命令

R状态–运行状态

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

S状态–阻塞状态

#include <stdio.h>    
#include <unistd.h>    
    
int main()    
{    
    int a=0;    
    while(1)    
    {    
        a=1+2;    
        printf("当前a的值是:%d\n ",a);                                                     
    };    
    
    return 0;    
}

为什么是S状态？

因为printf会访问显示器，显示器是外设的输入输出速度比较慢，CPU就会等待显示器就绪。99%都是在等I/O就绪，1%才是执行打印代码。所以当我们去查的时候，几乎大概率都会是S状态

t状态 --停止状态

进程处于此状态表示该进程正在被追踪，比如 gdb 调试进程：

T状态–停止状态

测试代码

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

kill -l

kill -19 [pid]–停止进程

后台运行

kill -18 [pid]–运行进程

后台运行–‘+’的消失

前台运行–有‘+’

用Ctrl+c不能杀死

就用kill -9 [pid]

总结：

先将该进程暂停后，再运行。进程状态前面的 + 号消失了，该进程变成了后台程序。但是对于后台进程来说，我们只能通过 kill 命令来杀死它。

D状态–深度睡眠

深度睡眠TASK_UNINTERRUPTIBLE：不可被信号唤醒；

浅度睡眠TASK_INTERRUPTIBLE：唤醒方式，等到需要的资源，响应信号；

深度睡眠场景：

有些场景是不能响应信号的，比如读磁盘过程是不能打断的，NFS也是；

执行程序过程中，可能需要从磁盘读入可执行代码，假如在读磁盘过程中，又有代码需要从磁盘读取，就会造成嵌套睡眠。逻辑做的太复杂，所以读磁盘过程不允许打断，即只等待IO资源可用，不响应任何信号；

应用程序无法屏蔽也无法重载SIGKILL信号，深度睡眠可以不响应SIGKILL kill-9信号；

注意：处于深度睡眠状态的进程既不能被用户杀掉，也不能被操作系统杀掉，只能通过断电，或者等待进程自己醒来。深度睡眠一般只会在高IO的情况发生下，且如果操作系统中存在多个深度睡眠状态的程序，那么说明该操作系统也即将崩溃了。

X–死亡状态

死亡状态代表着一个进程结束运行，该进程对应的PCB以及代码和数据全部被操作系统回收。

Z–僵尸状态

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

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

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

两个特殊的进程

Z(zombie)-僵尸进程

僵尸进程是处于僵尸状态的进程

脚本代码

while :; do ps axj | head -1 && ps axj |grep myprocess |grep -v grep; sleep 1; done

测试代码

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

子进程：pid= 26655

父进程：ppid=26654

当运行一段时间后的显现，26654进程因为打印变成S状态，由于26655退出了该进程变成僵尸进程。

在上面测试代码中

if(id == 0)
{
//child
while(1){
printf(“I am child process, pid: %d, ppid: %d\n”, getpid(), getppid());
sleep(5);
exit(1);
}
}

子进程通过5秒后退出，结合观察得到再子进程（26655）退出后，父进程（26654）变成了僵尸状态。

26654 26655 26654 5238 pts/0 26654 Z+ 1005 0:00 [myprocess]

的意思失效

意味着该进程是失效的，死掉的

当我们再观察进程时，我们发现该进程不在了，其原因是关掉了父进程，该失效的子进程被系统回收了。

僵尸进程危害

进程的退出状态必须被维持下去，父进程需要一直知道子进程的状态，随时进行处理。可父进程如果一直不读取，那子进程就一直处于Z状态。

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

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

孤儿进程

测试代码

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

最开始代码跑起来时，父进程pid=8644，bash=5238；子进程的pid=8645，子进程的父进程8644；他们的运行状态都是S状态–因为在打印就会访问I/O；

当我们销毁子进程时，kill -9 8645；我们发现子打印进程不在了，但是子进程的状态还在，变成了Z状态，这个时候就只能等父进程退出，让操作系统进行回收。

当我们杀掉父进程时，子进程被操作系统领养了，这个过程就叫做孤儿进程

当整个进程变成孤儿了，我们发现我们用Ctrl + c 是不能退出的；我们细心就会发现最开始子进程是S+当变成孤儿进程了，它的状态就是S了。说明了该程序变成了后台程序。

那么这个时候我们就只有用kill -9 16866，杀掉子进程了

进程优先级

基本概念

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个级别

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

top

1.非root用户：sudo top 进入top

2.在top中按r

3.输入进程pid

4.输入nice值

这里是输入nice值为100，我们发现最大区间是99 -19

这里是输入nice值为-100，所以我们发现最小大区间是60-20

经过上面两个例子，我们就发现其实我们只能改变范围是-20至19，一共40个级别

我们再观察一个场景，当我们把nice值改9的时候，我们发现值变成89，那么就得出结论：每次改nice值都在默认nice值的基础上进行改动，而不是修改之后。

其他概念

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

进程切换

测试代码

#include <stdio.h>      
      
int main()      
{      
    int a=10;      
    int b=10;      
    int c=b+a;      
      
    printf("%d\n",c);      
    a=20;      
    b=30;      
    c=b+a;      
      
   printf("%d\n",c);                                                                                                                                                                       
    return 0;                                                                                                                   
}

我们从该代码中不难看出，a，b，c都是临时变量，在以前c语言也知道，他们的数据都是存放在寄存器里的，这里我们发现寄存器里的数据是可以发生改变的。这里我们进入vs2013查看反汇编，数据都是加载到寄存器中的。

在这里有一个概念需要知道：CPU虽然只有一套寄存器，但是寄存器的数据是属于当前进程的。这里的寄存器其实更偏向于寄存器内的数据，而不是寄存器硬件。

在这个过程中运行的时候，占有CPU进程不是一直要占有到进程结束！因为CPU虽然只有一套寄存器而且还要对其他进程进行处理，进程在运行的时候，都会有自己的时间片

操作系统会对每个进程进行设置一个时间片，让CPU去读取进程数据进行处理，就会有进入/退出–进程的切换。在这个切换的过程中寄存器数据需要被保护和恢复。

进程在切换的时候，要进行进程的上下文保护，当进程在恢复运行的时候，要进行上下文的恢复。

在任何时刻，CPU里面的寄存器里面的数据，看起来是在大家都能看到的寄存器上，但是，寄存器内的数据，只属于当前运行的进程！

寄存器被所有进程共享，寄存器内的数据，是每个进程各自私有的—上下文数据

环境变量

基本概念

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

常见环境变量

PATH : 指定命令的搜索路径

我们直接输入test我们发现，编译不起

我们将我们写的可执行程序放入usr/sbin路径中，需要注意的这个文件目录只有root用户可以进去

这种是不支持的，会污染指令池；

sudo rm /usr/bin/test.o —删除

一般情况下，我们是选择用

exprot PATH=$PATH:

我们发现使用exprot PATH=$PATH: test.o 的路径还是在11-19中

总结：

1.PATH就是系统默认的搜索路径

2.系统的指令能被找到就是因为环境变量PATH本来就默认带了系统对于的路径搜索

3.which底层实现就使用环境变量PATH来进行路径搜索

系统会默认将.bash_profile执行一次，将环境变量导到shell中，也就是说环境变量的配置也就是.bash_profile 再启动的时候加载到bash中

vim .bash_profile–进入.bash_profile

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

用root和普通用户，分别执行 echo $HOME ,对比差异 . 执行 cd ~; pwd ,对应 ~ 和 HOME 的关系

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

和环境变量相关的命令

echo: 显示某个环境变量值

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

env: 显示所有环境变量

unset: 清除环境变量

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

USER

测试代码

#include<stdio.h>    
#include <string.h>    
#include <stdlib.h>    
    
#define USER "USER"                                                                                                                                                                        
    
int main()    
{    
    char *who =getenv(USER);    
    if(strcmp(who,"root")==0)    
    {    
    
    printf("hello world\n");    
    printf("hello world\n");    
    printf("hello world\n");    
    printf("hello world\n");    
    }    
    else{    
        printf("权限不足");    
    }    
    
    return 0;    
}

这里说明不同的环境变量运用的场景不同

echo- export

测试代码

#include<stdio.h>    
#include <string.h>    
#include <stdlib.h>    
    
#define USER "USER"    
#define MY_ENV "myval"    
    
int main()    
{    
    
    char *myenv=getenv(MY_ENV);    
    if(NULL==myenv)    
    {    
        printf("%s,not found\n",MY_ENV);    
        return 1;                                                                                                                                                                          
    }    
    printf("%s=%s\n", MY_ENV, myenv);    
    
    
    return 0;    
}

我们自己定义一个变量，但是我们用echo 查看发现在当前文件能查看，但是用env去找不到。因为是这里相当于是定义的局部变量

本地变量只会在当前进程（bash）内有效

我们用export将本地变量导成环境变量

然后我们在运行test.o，我们发现myval可以被test.c引用

这里我们就得出结论：环境变量具有全局性，是会被子进程下去。

bash是一个系统进程，myval也是一个进程（fork），那么为了满足不同的场景，bash会帮助我们找指令路径，身份认证；

set

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

unset

env

其他相关指令

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

命令行前两个参数

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

#define USER "USER"
#define MY_ENV "myval"
#define MYPWD "PWD"

int main(int argc, char *argv[])
{

        if(argc != 2)
        {
            printf("Usage: \n\t%s [-a/-b/-c/-ab/-bc/-ac/-abc]\n", argv[0]);
            return 1;
        }
        if(strcmp("-a", argv[1]) == 0)
        {
            printf("功能a\n");
        }
        if(strcmp("-b", argv[1]) == 0)
        {
            printf("功能b\n");
        }
        if(strcmp("-c", argv[1]) == 0)
        {
            printf("功能c\n");
        }
        if(strcmp("-ab", argv[1]) == 0)
        {
            printf("功能ab\n");
        }                                                                                                                                                                                  
        if(strcmp("-bc", argv[1]) == 0)
        {
            printf("功能bc\n");
        }    
  return 0;
}

就好比同一个程序，有多个选项控制

命令行第三个参数

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

  #include <stdio.h>    
  #include <unistd.h>    
  #include <string.h>    
  #include <stdlib.h>    
      
  #define USER "USER"    
  #define MY_ENV "myval"    
  #define MYPWD "PWD"    
      
int main(int argc, char *argv[],char *env[] )    
  {    
      
       extern  char **environ;    
       int i=0;    
      for ( i = 0; environ[i]; i++)                                                                                                                                                        
      {    
          printf("%d:%s\n", i, environ[i]);    
      }    
      
      return 0;    
  }

getenv

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

在这个三个获取环境变量的方式：getenv，char*env,extren char **environ中一般推荐使用getenv；因为一般情况我们不需要把全部变量都获取，都是按照自己的需求来。

总结：

在操作系统中用来指定操作系统运行环境的一些参数，我们在启动系统的时候bash就会自动更新该数据，相应的环境变量都有相应的应用场景，一些简单的指令其实就是函数调用环境变量。

程序地址空间

用段代码感受父子进程地址

进程之间是相互独立，都有自己的pdb

测试代码

#include <stdio.h>                                                                         
#include <unistd.h>    
    
int global_value = 100;    
    
int main()    
{    
    pid_t id = fork();    
    if(id < 0)    
    {    
        printf("fork error\n");    
        return 1;    
    }    
    else if(id == 0)    
    {    
        int cnt = 0;    
        while(1)    
        {    
            printf("我是子进程, pid: %d, ppid: %d | global_value: %d, &global_value: %p\n", getpid(), getppid(), global_value, &global_value);        
            sleep(1);    
            cnt++;    
            if(cnt == 10)    
            {    
                global_value = 300;    
                printf("子进程已经更改了全局的变量啦..........\n");    
            }    
        }    
    }    
    else    
    {    
        while(1)    
        {    
            printf("我是父进程, pid: %d, ppid: %d | global_value: %d, &global_value: %p\n", getpid(), getppid(), global_value, &global_value);        
            sleep(2);    
        }    
    }    
 }    
    else    
    {    
        while(1)    
        {    
            printf("我是父进程, pid: %d, ppid: %d | global_value: %d, &global_value: %p\n", getpid(), getppid(), global_value, &global_value);        
            sleep(2);    
        }    
    }    
    sleep(1);
}

运行这段代码后，我们发现运行一段时间后，子进程和父进程的地址是一样的，但是他们global_value值却发生了改变，这个是为什么呢？

这里我需要想一下，这里地址没变，那么这个地址是什么？如果是物理地址父子进程的必须是一样，不然硬件是无法执行。那么这里就很显然就不是物理地址，就是我们提到的程序地址空间

为了解决父子进程地址一样，值不一样的现象，我们必须将程序地址空间搞清楚

感性理解程序地址空间

每个进程都会认为自己是操作系统的第一把手，只要操作系统批准自己随时都可以独占整个系统资源，又因为进程是独立，每个进程也不会知道自己会有其他进程，但是实际上是有多个进程需要操作系统进行分配，进程是不知道系统资源的多少。为了满足进程独占这个系统资源的需求，操作系统就给进程给了一个虚拟的地址空间（好比花了一个饼）。如果这是进程想全部的系统资源，这个时候操作是老大，他说不，进程还有没有能力取代他。

尽管操作系统就给进程花了一个饼，但是后面操作系统会将这个饼实现，就好像一个公司老板给员工们构建一个蓝图，最后将它实现。老板在画饼之前，可能会需要想好：公司会有好多人，会挣好多钱，在什么时间上市。这个过程在计算机中我们称之为**描述，**描述我们就可以用数据结构，使用结构体进行描述：

struct 蓝图{

char *who;

vchar *when:

char *target;
char *money;

//个岗位

}

那么操作系统对进程画的饼：是内核的一种数据结构：mm_struct

mm_struct{

内存空间的大小

}

程序地址空间是什么

我们在学c/c++的时候，指针指向的就是这虚拟地址空间，我们编写代码经过编译，链接后形成可执行文件，前面也讲过进程就是可执行程序的实例，里面设计到的地址，都是虚拟地址空间。

地址空间描述的基本空间大小是字节，32位下就是2的32次方个地址，2的32次方*1字节就等于4GB空间范围。每个字节都有唯一的地址。

程序地址空间–区域划分

如上图，有各种区：代码区，堆区，栈区等等，这些都是一段空间范围，假设：就好比堆区是0x0FFF1111–0x2FFFFFFF这个范围的地址空间。整个地址空间范围：0x00000000–0xFFFFFFFF

如果不是很好理解，在我们中小学时期，女生就很喜欢给同桌的男生画一个三八线，这个时候女生就相当于操作系统，给两个人都有使用的范围。比如一张课桌是100cm，我们用一把尺子来划分区域，女孩的区域是0，60，男孩的区域是60，100，那么计算机是怎么描述这个事情呢？

struct area
{
unsigned long start;
unsigned long end;
};
struct area girl = {0,50};
struct area boy = {50,100};

那么回到进程地址空间的每个区上，我们知道整个区都地址范围，还知道程序地址空间是用结构体描述的，那么我们就大概知道地址空间是什么了–如图。

mm_struct{

uint32_t code_start,code_end;

uint32_t date_start,code_end;

uint32_t head_start,code_end;

uint32_t stack_start,code_end;

}

Linux mm_struct 中关于区域划分的部分源码如下：

struct mm_struct
{
unsigned long code_start;//代码区
unsigned long code_end;

unsigned long init_start;//初始化区
unsigned long init_end;

unsigned long uninit_start;//未初始化区
unsigned long uninit_end;

unsigned long heap_start;//堆区
unsigned long heap_end;

unsigned long stack_start;//栈区
unsigned long stack_end;
//…等等
}

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前在阿里

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上运维知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以点击这里获取！

,code_end;

uint32_t stack_start,code_end;

}

Linux mm_struct 中关于区域划分的部分源码如下：

struct mm_struct
{
unsigned long code_start;//代码区
unsigned long code_end;

unsigned long init_start;//初始化区
unsigned long init_end;

unsigned long uninit_start;//未初始化区
unsigned long uninit_end;

unsigned long heap_start;//堆区
unsigned long heap_end;

unsigned long stack_start;//栈区
unsigned long stack_end;
//…等等
}

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前在阿里

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
[外链图片转存中…(img-9MBg7QjO-1714631949385)]
[外链图片转存中…(img-lo04itRB-1714631949386)]
[外链图片转存中…(img-Wj8td5oa-1714631949386)]
[外链图片转存中…(img-kB0SGFPn-1714631949386)]
[外链图片转存中…(img-eXtVDLnx-1714631949386)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上运维知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以点击这里获取！

2401_83621603

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
最新Linux--进程概念_gid是进程(2)

1.一个CPU一个运行队列2.让进程入队列的本质是：将该进程的struct stsk_struct结构体对象放入运行队列中3.进程PCB在runqueue，就是R–运行状态，而不是这个进程正在运行才叫运行状态4.进程不只会等待（占用）CPU资源，也可能随时随地要外设资源5.所谓的进程不同的状态，本质是进程在不同的队列中，等待某种资源。
复制链接

扫一扫