进程基础

╰半夏微凉° 2023-05-29 03:45 3阅读 0赞

### 进程的基本概念 ###

*  **程序顺序执行的特征：**
    
    1）顺序性：处理机严格按照程序所规定的顺序执行，每一步操作必须在下一步操作开始前执行
    
    2）封闭性：程序在封闭的环境下运行，程序独占资源，资源的状态由程序决定，程序一旦开始执行，外界环境不会影响程序的执行结果。
    
    3）可再现性：只要程序的初始条件和环境相同，程序的执行结果就相同。
 *  **程序的并发执行的特征：**（顺序执行会浪费资源）
    
    1）间断性：程序共享系统的资源，以及为完成同一个任务共同合作，并发执行的程序之间相互制约，（不是运行完一个在运行另一个）
    
    2）失去封闭性：各程序共享系统资源，资源的状态由各程序所决定。
    
    3）不可再现性：由于失去了封闭性，（即初始的环境状态和条件相同，程序的执行结果却可能不同），该特征超级垃圾，必须想办法避免。
 *  **进程的概念：**
    
    具有独立功能的程序在某一个数据集合上的执行过程，它是系统进行资源分配和调度的一个独立单位。
 *  **进程的特征：**
    
     *  结构特征：
        
        <table> 
         <thead> 
          <tr> 
           <th>PCB（进程控制块），与进程共存亡，用于记录进程的基本情况和活动过程，一般常驻内存</th> 
          </tr> 
         </thead> 
         <tbody> 
          <tr> 
           <td>程序段（一般为需要的时候动态调入内存），描述要完成的功能</td> 
          </tr> 
          <tr> 
           <td>数据段（一般为需要的时候动态调入内存），操作的对象即工作区</td> 
          </tr> 
         </tbody> 
        </table>
     *  动态性：进程最基本的特征，进程不是静态的，而是动态的，它由创建而产生，由调度（这里主要指**进程调度**，而不是作业调度）而执行，由撤销而消亡
     *  并发性：指多个进程实体存于内存中，且能在同一时间段内执行，（这里同操作系统的并发性）
     *  独立性：进程实体是一个能独立运行，独立获得资源和独立接收调度的基本单位
     *  异步性：同操作系统的异步性
 *  **进程的三种基本状态：**
    
     *  就绪状态：进程已经分配到除了CPU之外的所有资源，只要获得CPU便可以立刻执行，处于就绪状态的进程维持一个就绪队列。
     *  执行状态：已经获得CPU，正在执行的进程。（单处理机系统中，同一时刻只能有一个进程处于执行状态，多处理机系统中，可以同时有多个进程处于执行态）
     *  阻塞状态/等待状态：在执行的过程中由于发生某些事件（I/O请求，申请缓存等），暂时无法执行的进程，是由于进程**本身引起**的阻塞。处于阻塞状态的进程可以维持一个阻塞队列。
     *  进程是自己阻塞自己的，但是阻塞的进程需要其他进程将其唤醒
 *  **三种基本状态的转换：**

就绪—>执行：进程调度，获得CPU资源

执行—>就绪：在分时操作系统中时间片花完

执行—>阻塞：I/O请求，申请缓存等，自己被迫进入阻塞状态

阻塞—>就绪：I/O完成，造成阻塞的原因得到解决（又变成只差CPU的状态）

*  **进程的创建状态和终止状态**
    
    创建状态：进程成为就绪状态之前的状态
    
    终止状态：当一个进程到达了自然结束点，或者遇到无法客服的困难，或者被操作系统所终结等的时候，就进入了终止状态。
 *  **挂起操作及引入的原因：**
    
    1）进程被挂起之后处于静止状态。
    
    2）引入的原因：
    
     *  终端用户的需要：当终端用户想要暂停自己程序的运行的时候
     *  父进程请求：当父进程想要挂起某个子进程的时候
     *  负荷调节的需要：当实时系统中的工作负荷较重，系统可以将某些不重要的进程挂起，保证程序的正常运行。
     *  操作系统的需要：操作系统有事需要将某些进程挂起，已检查运行过程中资源的使用情况
    
    3）引入挂起操作后，进程的状态转换：
    
    （1）阻塞态可以通过释放变为就绪态。活动阻塞释放变为活动就绪，静止阻塞释放变为静止就绪。
    
    （2）活动态和静止态可以进行相互转换，活动到静止称为挂起，静止到活动可以称为激活。**活动态和静止态最本质的区别为活动态在内存中，静止态暂时调出内存，进入外存**
    
    （3由执行态可以直接变为静止就绪态，即时间片用完，直接调离内存
    
    （4）静止态（外存）必须通过激活变为非静止态（调入内存）才能够参与进程的三台转换。
    
    4）进程挂起之后不是原封不动的将进程移出内存，而是会先将一些必要的信息写入外存。再释放PCB
 *  **进程管理中的数据结构**
    
     *  操作系统中用于管理控制的数据结构：内存表，设备表，文件表，进程表（程序控制快PCB）
     *  **进程控制块PCB的作用：**
        
        1）作为独立运行基本单位的标志
        
        2）能实现间断性的运行方式
        
        3）提供进程管理所需要的全部信息
        
        4）提供进程调度所需要的全部信息
        
        5）实现与其他进程的同步和通信
     *  **进程控制块中的信息：**
        
        **进程标识符**：唯一表示一个进程，有两种：
        
        1）外部标识符：方便用户对进程的访问，通常有数字和字母组成
        
        2）内部标识符：方便系统对进程的访问，每一个进程有一个唯一的数字标识符。
        
        **处理机状态**：（主要指的是处理机中寄存器的状态）
        
        1）通用寄存器：又称为用户寄存器，用户的程序可以访问，用于暂存信息，一般为8~32个
        
        2）指令计数器：存放了将要访问的下一条指令的地址。
        
        3）程序状态字（PSW）：含有状态信息，条件码，执行方式（指在系统还是用户状态下执行），中断屏蔽标志（允不允许在执行的过程中被打断）
        
        4）用户栈指针：每个用户进程都有系统栈，用于存放过程和系统调用参数及调用地址。
        
        **进程调度信息**
        
        1）进程状态：指明了进程的当前状态
        
        2）进程优先级：即一个整数，用于描述进程使用CPU的优先级，数字越大，优先级越高
        
        3）其他信息：与采用的进程调度算法有关
        
        4）事件：指进程由执行状态变为阻塞状态所等待发生的事件。
        
        **进程控制信息**
        
        1）程序和数据的地址：由于程序段和数据段并不是常驻内存的，而是使用的时候才调入，因此需要保存其地址
        
        2）进程同步和通信机制：
        
        3）资源清单：一张清单列出了该进程在运行期间所需的全部资源（除了CPU资源），另一张列出了分配到该进程的资源的清单。
        
        4）链接指针：给出了本进程（PCB）所在队列中的下一个进程的PCB的首地址。
     *  进程控制块的组织方式：
        
        线性方式：不重要
        
        链接方式：类似静态链表，把具有同一状态的PCB用其中的链接字链接成一个队列
    
    > 注：进程资源的分配并不是在该进程执行之前将该进程所需的资源全部分配给他，而是在其执行的过程中进行动态的分配。

### 进程与程序的区别与关系 ###

*  进程与程序的区别：
    
     *  进程是一个动态的概念（有 “ 生命 ” ），程序是静态的概念。
     *  进程可以具有并行性（在多处理器的系统中），但是程序没有
     *  进程是竞争系统资源的基本单位
 *  进程与程序的关系：
    
     *  一个程序对应多个进程，一个进程又可以为多个程序服务。

### 进程控制 ###

1.基本知识

*  进程控制是进程管理中最基本的功能，主要包括进程的创建，进程的终止和运行中的进程的状态转换等功能。进程控制一般是由**OS的内核中的原语**来实现的。

2.进程的创建

*  进程的层次结构
 *  进程图
 *  **引起进程创建的事件**
    
    1）用户登录：在分时系统中，用户成功登录，系统将为该用户分配新的进程
    
    2）作业调度：在多道批处理系统中，作业调度程序将某些作业调度内存，并且为他们创建进程
    
    3）提供服务：运行中的用户程序提出某种请求
    
    4）应用请求：由用户进程自己创建，帮助自己完成特定的任务
 *  ==进程的创建过程：==OS调用进程创建原语Create创建一个新进程
    
    1）申请空白PCB：新进程获得一个唯一的**数字标识符（对于操作系统）**
    
    2）为新进程分配器运行所需的资源：包括**物理资源和逻辑资源**
    
    **3）初始化进程控制块PCB：**
    
    （1）初始化标识符信息：系统分配的标识符信息装入PCB
    
    （2）初始化处理机状态信息：主要为一些寄存器
    
    （3）初始化处理机控制信息：一般初始化为就绪状态
    
    （4）如果进程就绪队列允许，将进程插入就绪队列

3.进程的终止

*  引起进程终止的事件：
    
    1）正常结束
    
    2）异常结束：1）越界错误（访问自己范围外的），2）保护错误（访问自己无权利访问的）3）非法指令：试图运行不存在的指令，4）特权指令；5）运行超时；6）等待超时；7）算术运算错；8）I/O故障
    
    3）外界的干预：1）操作员或者操作系统干预；2）父进程的请求（父进程的权利大于子进程）3）父进程的终止：当父进程终止时，其所有子进程也应当终止。
 *  ==进程终止的过程：==OS调用进程终止原语
    
    1）根据要终止的进程的标识符，搜索出该进程的PCB，从中获得该进程所处的状态
    
    2）如果该进程正处于执行状态，立刻终止该进程，并且置调度标志为真，表示在该进程结束后应该进行重新调度（即不要让CPU空闲）
    
    3）若该进程有子孙进程，让其所有子孙进程都终止。
    
    4）被终止进程所拥有的所有资源归还给父进程或者操作系统
    
    5）将终止进程的PCB从所在队列中移除，等待其他程序来收集信息。

4.进程的阻塞与唤醒

*  引起进程阻塞和唤醒的事件：阻塞和唤醒是相对应的
    
    1）向系统请求共享资源失败
    
    2）等待某种操作的完成
    
    3）新数据尚未到达
    
    4）等待新任务的到达
 *  进程阻塞的过程：**进程**通过调用阻塞原语block==将自己==阻塞
    
    1）进入block后立即停止执行
    
    2）保存现场
    
    3）将进程控制块中的现行状态改为阻塞，并将PCB插入阻塞队列
    
    4）转调度程序，进行重新调度
 *  进程唤醒的过程：当阻塞的进程所期待的事件发生时，**有关进程**（不是本身）调用唤醒原语wakeup，将等待该事件的进程唤醒。唤醒之后进入就绪队列。
    
    1）将被阻塞的进程从等待该事件的阻塞队列中移除
    
    2）将PCB的现行状态由阻塞改为就绪
    
    3）然后再将该PCB插入就绪队列中
    
    4）转进程调度或者返回
 *  block原语和wakeup原语是一对作用刚好相反的原语，必须成对使用。

5.进程的挂起与激活

*  进程的挂起过程：当出现了引起进程挂起的事件之后，OS利用挂起原语将指定的进程挂起（即调出内存）
    
    首先检查进程的状态（不同的状态采取不同的处理方式），若该进程正处于活动就绪状态，将其改为静止就绪态；若该进程处于活动阻塞状态，将该进程改为静止阻塞状态；若该进程处于执行状态，将其改为静止就绪状态，调度程序重新进行调度。
 *  进程的激活过程：
    
    1）首先将进程从外存调入内存，
    
    2）检查进程所处的状态，如果进程处于静止就绪，将其改为活动就绪，如果处于静止阻塞，将其改为活动阻塞
    
    3）检查进程的优先级，如果优先级高，可以进行抢占当前运行进程的资源

### 4.进程同步 ###

1.进程同步的基本概念

*  进程同步的目的：1）按照一定的规则共享系统资源；2）对多个相关进程在执行次序上进行协调，是程序具有可再现性。
 *  两种形式的制约关系：
    
    1）间接相互制约关系：多个进程在并发执行时，由于**共享系统的临界资源**而相互制约，如磁带机，打印机，表格等。（互斥）
    
    2）直接相互制约关系：多个进程为完成同一任务而**相互合作**（同步）
 *  \*\*临界资源：\*\*一次仅允许一个进程使用的共享资源。例如打印机，磁带机，表格等。
 *  互斥和同步的概念：
    
    1）互斥：并发的多个进程由于竞争同一资源而产生的相互排斥的关系
    
    2）同步：进程间共同完成一项任务时直接发生相互作用的关系
 *  **临界区：每个进程中访问临界资源的那段代码**

/*一个访问临界资源的循环进程*/
    while(true)
    {
        进入区：//对欲访问的临界资源进行检查，查看其是否正被访问，如果此刻临界资源未被访问，进程便可以进入临界区对临界资源进行访问，并设置它正被访问的标志，如果此刻临界资源正被访问，则不能进入临界区。即后边的wait（）操作
        临界区：//执行临界资源的那段代码
        退出区：//将临界区正被访问的标志恢复为未被访问的标志，signal（）操作
        剩余区：//除上述三个区之外的代码叫做剩余区
    }

*  同步机制应遵循的原则：
    
    1）空闲让进
    
    2）忙则等待
    
    3）有限等待：不能一直等
    
    4）让权等待：进程不能进入临界区，就应当释放==处理机==，让权指让出处理机

2.硬件同步机制

3.信号量机制：Dijkstra提出

*  信号量：
    
     *  是一种数据结构
     *  值与相应资源的使用情况有关
     *  仅与P，V操作有关，**P，V**代表两种**原子操作**，P为等候原语wait（S）,V为释放原语signal（S）。
     *  wait操作即在申请资源，signal操作是释放资源
     *  wait操作其实就是进入临界区之前的进入区，signal操作是从临界区出来之后的退出区
     *  原子操作的特点，操作一开始执行，半中间不可以打断，原语即为原子操作。
 *  整型信号量
    
     *  概念：Dijkstra把整型信号量定义为一个用于表示资源数目的整型量S。
    
        /*等候原语*/
        wait(S){
            while(S <= 0);  //当S<=0的时候便一直处于等待状态，直到获得相应的资源，不符合让权等待的原则      
            S--;     //获得资源后，资源的数目减一，S表示该类资源可用的数目      
        }
        
        /*释放原语*/
        signal(S){
            S++;      //释放资源后，资源的数目加一     
        }
    
     *  优缺点：
        
        优点：实现简单
        
        缺点：**违背了同步机制中的让权等待原则**，浪费资源（只要S<=0，就会等待）
 *  \*\*记录型信号量：\*\*当前用的最多的
    
     *  特点：采用了记录型的数据结构
    
        /*记录型数据结构*/
        typedef struct{
            int value;      //>=0的时候，表示系统中可用资源的数量，<0的时候其绝对值表示因为该资源而阻塞的进程的数目
            struct process_control_block *list;    //维持阻塞队列的指针
        }semaphore;
        
        /*等待原语*/
        wait(semaphopre *S){
            S->value--;    //一个进程过来，首先将S->value--；
            if(S->value < 0){     //<0表示资源已经用光，将该进程加入阻塞队列
                block(S->list);
            }
        }
        
        /*释放原语*/
        signal(semaphore *S){
            S->value++;      //释放资源，S->value++；
            if(S->value <= 0){      //S->value++之后，还<=0，直接唤醒一个阻塞的进程，唤醒的进程拥有了该资源的使用权（不需要再次执行P操作），然后进入就绪队列。如果>0，直接将资源释放即可
                wakeup(S->list);
            }
        }
    
     *  wait操作：每次都相当于进程请求一个单位的该类资源
        
        signal操作：每次都相当于释放一个单位资源
     *  当S->value的初值为1的时候，表示只允许一个进程访问临界资源，信号量转化为互斥型信号量
     *  **优点：通过维持阻塞队列的指针，使得满足了让权等待的原则**，弥补了整型信号量的缺点
     *  \*\*缺点：\*\*只适用于对单一资源的管理，如果一个进程需要请求多类资源的时候，很容易产生死锁。
 *  AND型信号量：解决记录型信号量会发生的死锁的问题
    
     *  当一个进程需要两个或者更多的共享资源来完成一个目标的时候，多个进程之间可能会发生阻塞（刚开始前半部分资源占有了，但是后半部分资源无法获得，自己再阻塞自己，即发生了死锁）
     *  AND的解决思想：**将一个进程运行过程中所需要的全部资源一次性都分给他，待进程使用完之后，在一起进行释放。**（即一起申请，一起释放）
    
        /*等候原语：全分配*/
        Swait(S1, S2, …, Sn)
         {
            While(TRUE)
            {
                //多类资源同时满足的时候才进行分配，先判断再分配。
            	if (S1 >=1 and … and Sn>=1 ){
                  	for( i=1 ;i<=n; i++) Si - -;
        			break;
        		}
                else{
                    Place the process in the waiting queue associated with the first Si found with Si <1,and set the progress count of this process to the beginning of Swait operation	（将即将阻塞的进程挂到第一个不能满足他的资源的阻塞队列，然后设置该进程的起始地址为Swait操作的开始）
                }
            }
        }
        
        /*释放原语：全释放*/
        Ssignal(S1, S2, …, Sn){
        	while(TRUE){    
        		for (i=1; i<=n; i++) {
                    Si++ ;
                    Remove all the process waiting in the queue associated with Si into the ready queue（将因为该资源得不到满足而阻塞的所有进程都从阻塞队列释放进入就绪队列，重新进行排队）
          		 }
        	}
        }
    
    **注意：**
    
    1）在分配资源的时候首先判断是否所有资源均全部满足相应的条件，满足才进行分配。
    
    2）释放的时候是将因为该资源得不到满足而阻塞的**所有进程都从阻塞队列释放进入就绪队列**，重新进行排队，因为OS需要根据调度算法重新选取新的进程占据CPU
 *  **信号量集**

Swait(S1, t1, d1; …; Sn, tn, dn)
        if (S1>= t1 and … and Sn>= tn) then
            for i:=1 to n do
               Si:= Si - di ;
            endfor
        else
           Place the executing process in the waiting queue of the first Si with Si < ti and set its program counter to the beginning of the Swait Operation
        endif

**注意：**

1）继承了AND型信号量的思想，先判断是否所有所需资源均满足条件。满足才进行分配。

2）**引入了下限值**的概念。Si表示可用的资源的数量；ti表示想要分配资源成功至少需要的该资源的数目（ti（下限值）包括两部分，一部分是系统执行该进程所需，另一部分是该进程所请求的，因此一般大于di）；di表示该进程所请求的该类资源的数目。

4.信号量的应用

1、利用信号量实现**进程互斥**

semaphore  mutex =1;
        begin
        parbegin
            process 1: begin
                            repeat
                                wait(mutex);
                                critical section
                                signal(mutex);
                                remainder section
                            until false;
                        end
            process 2: begin
                            repeat
                                wait(mutex);
                                critical section
                                signal(mutex);
                                remainder section
                            until false; 
                        end
        parend        
        end

**注意：**

1）利用信号量实现进程互斥地访问某种资源。首先应将mutex设为1

2）wait操作和signal操作必须成对地出现，如果缺少wait操作可能会造成系统的混乱；如果缺少signal操作，那么该资源永远不会得到释放，因该资源而被阻塞的进程也将永远不会被唤醒。

2、利用信号量**实现前驱关系图**（进程同步）

**如下图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70][]

semaphore  a, b, c, d, e, f, g = 0, 0, 0, 0, 0, 0, 0;
        begin
            parbegin
                begin  S1; signal(a); signal(b); end;
                begin  wait(a); S2; signal(c); signal(d); end;
                begin  wait(b); S3; signal(e); end;
                begin  wait(c); S4; signal(f); end;
                begin  wait(d); S5; signal(g); end;
                begin  wait(e); wait(f); wait(g); S6; end;
            parend
        end

**注意：**

1）信号量的初值必须被设置为0，必须等某个进程之前的进程完之后，释放资源，后边的进程才能够执行。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191103201129416.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9mYW50aWFuenVvLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70