操作系统与进程（1）

冯诺依曼体系结构

冯诺依曼体系结构

1.输入设备：键盘，磁盘（外设，读取文件（没读的时候就在磁盘）），网卡，显卡，话筒，摄像头(效率是s,ms级别)
2.输出设备：显示器，打印机，磁盘（写文件，就是把数据写到磁盘上），网卡，显卡，音箱等
3.存储器（内存）：离cpu越近的设备存储效率越高也越贵，有了内存，cpu就不用直接和外设打交道，存储器的快慢决定快慢（内存是体系结构的核心设备）
4.运算器&&控制器（CPU）：运算器（算术运算与逻辑运算）
控制器（读取指令，分析指令，执行指令）（效率ns级别）

如
a和b通过qq发消息

任何的外设，在数据层面，基本都是有限和内存打交道！，
cpu，在数据层面上，也直接和内存打交道

操作系统

启动的（将软件数据与代码，加载到内存中）操作系统，才有意义

是什么

OS 是一款软件，专门针对软硬件资源进行管理工作的软件
（核心工作就是做管理的）

为什么

对下：管理好软硬件资源。对上：给用户提供稳定高效安全的运行环境
方式 目的

怎么办

核心在管理，管理是对人的属性数据进行管理，描述属性结合的就是结构体，里面就有被管理者的全部数据，再加个联系指针连接起来（链表，哈希，树等），对学生的管理就变成了对链表的管理，对学生的褒奖工作就变成了对链表的增删查改

本质（先描述再组织）

管理理念：先描述，再组织，
可以转化成对目标的管理，
转化成对数据的管理

进程（软件）

加载到内存的程序就叫做进程
系统中可能存在大量的进程，操作系统要管理进程
如何管理进程？

先描述，再组织
任何进程在形成的时候，操作系统要为该进程创建PCB，进程控制块（ 先描述，struct PCB 里面就是进程的所有属性，结构体描述），

PCB

OS 上面，PCB 进程控制块，就是一个结构体类型
在Linux系统中，PCB ->struct task_struct{ //进程的所有属性 }

类比shell和bash的关系
类比媒婆和王婆的关系

如

我们所有启动的程序的过程都是在系统上面创建进程

把程序运行起来，就是把程序加载到内存，就是把程序由磁盘加载到内存中变成一个进程
进程的属性
程序运行结束进程就结束了

进程vs程序

有了进程控制块，所有进程管理任务与进程对于的程序毫无关系！！！
与进程对应的内核创建的进程的 PCB 强相关

进程=程序+操作系统维护进程的相关数据结构（更多的数据结构）（进程控制块）

PCB的内部构成

• pid：描述本进程的唯一标识符，原来区别其他进程

结束进程
kill -9 pid

• ppid:获得其父的pid（在命令行上运行的命令，基本上其父进程都是-bash）

• 状态：任务状态，退出代码，退出信号等。
  0
  输出离他最近执行命令的退出码
  

• 优先级：相对于其他进程的优先级，CPU 只有1个，进程有非常多个，确认先后的问题，

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

• 内存指针：可以通过PCB 找到对应的代码和数据

• IO状态信息：进程可能要进行的IO，（从输入设备读入）（输出设备读出），进程在进行IO，

• 记账信息：进程被os调度器调度的信息（os为了较为均衡的调用每个进程（获得cpu的资源（进程被执行））），有处理器时间总和，使用的时间限制，记帐号

• 上下文数据：（进程执行时处理器的寄存器中的数据）寄存器（当前正在运行的进程的临时数据）
  时间片（单次运行每个进程的最大时间10ms，没跑完，排到最后等待继续运行），在cpu情况下，用户感受到多个进程都在运行（靠cpu快速切换完成的），进程在运行期间是由切换的，进程可能存在大量的临时数据----》暂时在cpu的寄存器中保存，

保护上下文
恢复上下文
虽然寄存器硬件只有一份，但是寄存器里面的数据是你这个进程的，走的时候，把寄存器里面的数据返回pcb里面，进入下一个进程，等待下一次使用，再进入时，再把之前的临时数据放回cpu

通过上下文的保护和恢复，我们可以感受到进程被切换的

查看进程的方案

ls /proc


exe就是当前执行的文件路径
cwd就是当前工作路径

fork

fork就是用来创建子进程的

---

演示

1 #include <iostream>
  2 using namespace  std;
  3 #include<unistd.h>
  4  
  5 int main()
  6 {                                                                 
  7     fork();//创建子进程
  8     cout<<"hello proc "<<getpid()<<"hello parent "<<getppid()<<endl;
  9     sleep(1);                                                                                   
 10     return 0;                                                                                    
      
 11 }    

上面的代码我们fork后，只写了一行的打印，但是运行结果是有两条的内容

如何理解fork创建子进程

1. 有我们在命令行里面./cmd or run command(执行指令) ,与fork相比：在操作系统角度上，创建进程的方式都是没有差别的，只不过fork创建的进程间有父子关系

2. fork本质是创建进程 ----> 系统里面多了一个进程 —>在系统里面多了一份与进程相关的内核数据结构 （task_struct） + 进程的代码和数据(我们只是fork了，创建了子进程，但是子进程对应的代码和数据)---------》

• 默认情况下，会继承父进程的代码和数据
• 内核数据结构task_struct 也会以父进程为模板，初始化子进程的task_struct

例如父亲是做鞋的工厂老板，那么你就会继承父亲的基因（数据结构），同时你也会子承父业继续做鞋（继承代码和数据）

---

进程具有独立性

1. 代码

• fork之后子进程和父进程代码是共享的
• 代码是不可以被修改的
• 父子代码只有一份

2. 数据

• 默认情况下“数据也是共享的”，不过因为进程具有独立性，所以也要考虑修改的情况
• 可以通过“写时拷贝”来完成进程数据的独立性

fork的返回值

我们创建的子进程，就是为了和父进程干一样的事情？？？

一般是没有意义的，我们一般还是希望要让父进程和子进程做不一样的事

我们通常是用fork的返回值来完成

• 失败: <0
• 成功:
  • 给父进程返回子进程的pid
  • 给子进程返回0

 1 #include <iostream>                                                       
  2 using namespace  std;             
  3 #include<unistd.h>  
  4 #include <sys/types.h>  
  5 int main()  
  6 {  
  7     pid_t id=fork();//获得其返回值 
  8     cout<<"hello proc "<<getpid()<< " hello parent "<<getppid()<<" ret: "<< id <<endl;  
  9     sleep(1);                                                                                            
 10     return 0;                                                                      
 11 }    

1. 如何理解有两个返回值？

   如果一行函数已经执行return，那么函数的核心功能执行完了

   pid_t fork()
   {
   //创建子进程的逻辑
   
    return XXX;//也是语句，父子共享return
   }
   

   到return的时候，他创建子进程的逻辑也完了，所以子进程已经有了，父进程要return，子进程也要return

   • 返回的是数据吗？return的时候也会写入吗？

     返回的也是数据，会，发生了写时拷贝

2. 如何理解两个返回值的设置

   父：子=1：n，

   子进程的父进程只有1个，而父进程可以有很多的子进程，所以要得到其子进程的pid来控制子进程，而子进程通过ppid就可以找到父进程

对多进程的控制

#include<iostream>
#include<unistd.h>
using namespace std;
int main()
{
    pid_t id=fork();
    if(id==0)//利用if else，进行分流，实现父子进程完成不同的事
    {
//child
        while(true)
        {
			cout<<"I am 子进程 pid="<<getpid()<<" ppid="<<getppid()<<endl;
            sleep(1);
        }
    }
    else if(id>0)
    {
		while(true)
        {
			cout<<"I am 父进程 pid="<<getpid()<<" ppid="<<getppid()<<endl;
            sleep(2);
        }
    }
    else
    {
		//todo
    }
    sleep(1);
    return 0;
}

fork之后谁先跑呢？？

不确定

进程状态

进程的状态信息在哪里呢？？
在 task_struct(PCB)

进程状态的意义：

方便OS 快速判断进程，完成特定的功能，比如调度，本质是一种分类

具体的状态

• R：运行态，不一定正在CPU上面正在运行，但是如果处于运行的队列（等待CPU）中，那么这些状态都可以称为R状态，随时都可以被CPU进行调度

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p20zfQoB-1647504125418)(picture/image-20220310140329017.png)]

• S/D：睡眠状态，当我们想要完成某种任务的时候，任务条件不具备，需要进程进行某种等待时，就S，D，等待资源就绪

  如：今天想打游戏，但是电脑没开，那么我们就要开机等待电脑开机，那么此时我们就是S，D

  ---

  所谓的进程，在运行的时候可能会因为运行的需要，可以会在不同的队列里，

  在不同的队列里面，所处的状态是不一样的

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3K13Q8eR-1647504125419)(picture/image-20220310141732027.png)]

如果资源就绪了那么S状态就变成了R状态，放到运行队列里，

如果这个进程突然卡死了，那OS就会把他从运行队列放到等待队列里面去

我们把，从运行状态的task_struct（run_queue）,放到等待队列中，就叫做挂起等待（阻塞）

从等待队列，放到运行队列，被CPU调度，就叫做唤醒进程

#include<iostream>
#include<unist.h>
int main()
{
    sleep(10);
    cout<<"hello "<<endl;
return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0vxSbIJj-1647504125420)(picture/image-20220310144349978.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uAi5lsGD-1647504125420)(picture/image-20220310143310732.png)]

等待我们设定的10s就绪，那么他就处于S状态，

可以直接立即终止（可中断睡眠）

• 深度睡眠 ；不可中断睡眠，

  假设进程发出了一个命令，要将1t数据（数据量非常大）都放到磁盘里面，让磁盘去读写，之后磁盘就开始工作了，这个时候进程就开始等待

  等待磁盘把任务完成，这个时候，OS来了发现进程在休息，就把他给杀掉了，

  磁盘读写完了，要把失败与否的结论告诉进程，但是发现进程不见了，

  进程：是OS把我杀掉的

  磁盘：是进程不见的

  没有办法解决问题

  ---

  本质上是因为操作系统把正在等待的进程给杀掉的

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JH3pVRNg-1647504125421)(picture/image-20220310153558797.png)]

所以为了解决这个问题，就有了深度睡眠的D状态，

进程进入了D状态，不可被杀掉

• T :暂停状态，完全暂停不会因为某种条件达成变成R,做某些任务的时候，进程需要暂停

• t（trace stop）：经常调试程序的时候，在调试的时候，进程所处的状态，打个断点，就停下来了，临时查看很多资源数据

• x（dead）：死亡状态，回收进程资源=进程相关的数据结构+你的代码和数据（和创建的操作是一样的），死亡状态无法查到

• z（zombie）：僵尸状态，先进入僵尸状态再进入死亡状态

  ---

  • 为什么要有僵尸状态

    为了辨别退出死亡原因，进程退出时要暂时保存退出的信息

    在task_struct存了进程退出的所有信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VWpdwoVG-1647504125421)(https://raw.githubusercontent.com/zevin02/image/master/%20202203121022560.png)]

状态代码验证

R

：没有IO ，所以就不用等待

  1 #include<iostream>
  2 using namespace std;
  3 int main()
  4 {
  5     while(true);
  6     return 0;                                                                                            
  7 }

S

  1 #include<iostream>
  2 using namespace std;
  3 int main()
  4 {
  5     while(true)
  6     {
  7        cout<<"hello"<<endl;
  8     }                                                                                              
  9     return 0;         
 10 }                     
~         

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RYSD1QuG-1647504125422)(https://raw.githubusercontent.com/zevin02/image/master/%20202203111201188.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w6blxo0h-1647504125423)(https://raw.githubusercontent.com/zevin02/image/master/%20202203121024675.png)]

有可能还能检测到r状态

打印，是往显示器打印，外设慢，IO，实际上等待外设就绪是很慢的，所以大部分状态都是S状态，CPU太快了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NWVrfyha-1647504125423)(https://raw.githubusercontent.com/zevin02/image/master/%20202203121028603.png)]

暂停进程

继续进程

后面没有+号，在后台运行

但是按ctrl c无法结束进程

结束进程

+

：带了+，说明是在前台运行，在命令行输入任何内容都是没有用的，但是ctrl c来干掉进程

后台进程./myproc &，就变成后台进程，可以在命令行中输入命令，无法用ctrl c来结束进程，只能用kill -9 pid来结束进程

z

如果没有人检测回收进程（父进程），该进程退出或进入z

1 #include <iostream>                                                                                
  2 #include<unistd.h>
  3 using namespace std;
  4 int main()                                       
  5 {                 
  6     pid_t id=fork();
  7     if(id==0)
  8     {                 
  9        //child       
 10        while(true)
 11       {                
 12          cout<<"I am child,running"<<endl;
 13           sleep(2);
 14        }                                   
 15     }                                       
 16     else           
 17     {  
 18        //father
 19        cout<<"I am father ,doing nothing"<<endl;
 20        sleep(50); 
 21     }  
       return 0;
 22 }
      

把子进程给终止掉，但是父进程没有回收，就变成了僵尸进程

（子进程先死了，父进程还在运行）

孤儿进程

被1号进程领养，1号进程也叫做操作系统OS

父进程终止了，子进程还在运行

  1 #include <iostream>                                                                                
  2 #include<unistd.h>
  3 using namespace std;
  4 int main()                                       
  5 {                 
  6     pid_t id=fork();
  7     if(id==0)
  8     {                 
  9        //child       
 10        while(true)
 11       {                
 12          cout<<"I am child,running"<<endl;
 13           sleep(2);
 14        }                                   
 15     }                                       
 16     else           
 17     {  
 18        //father
 19        cout<<"I am father ,doing nothing"<<endl;
 20        sleep(10);
     exit(-1);
 21     }  
       return 0;
 22 }

进程优先级

为什么会有优先级？

本质上是资源太少的问题，优先级本质是获得资源，分配资源的一种方式

查看进程的方案

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 int main()
  4 {
  5   while(1)
  6   {
  7   ¦ printf("I am a process ,pid %d,ppid %d\n",getpid(),getppid());                           
  8   ¦ sleep(1);
  9   }
 10   return 0;
 11 }
~

UID 相当于我的名字，不过他是以数字来标识（类似身份证号码）

PRI就是优先级数据

NI优先级的修正数据，

linux中的优先级数据，值越小，优先级越高，

就尽快的享受到某种资源

PRI vs NI

加入nice值，PRI（new）=PRI（old）+nice

所以nice为正，优先级变满，

反之亦然

特别不建议自己修改优先级

优先级设置

nice值（-20~19）

old不会因为之前的改变而改变，还是一开始的值

nice值为什么是一个相对小的范围

优先级再怎么设置，也只能是一种相对的优先级，不能出现绝对的优先级，避免有的进程出现饥饿问题，而我们的调度器

就是为了较为均衡的让每个进程享受到CPU资源，