操作系统专项练习（二）

1、路径问题

绝对路径（全路径）：从根目录开始到所要查找的路径

当前目录：从当前位置到所要查找的路径。系统设置当前工作目录的主要目的是加快文件的检索速度。节省外存空间，节省内容空间，加快文件的读写速度都与设置当前工作目录无关。

2、并发和并行

（1）并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

                       一个指令多个进程交替执行

（2）并行：指在同一时刻，有多条指令在多个处理器上同时执行。

           多个指令在多个进程上执行

（3）并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在，并发能够在单处理器系统中存在是因为并发是并行的假象，并行要求程序能够同时执行多个操作，而并发只是要求程序假装同时执行多个操作（每个小时间片执行一个操作，多个操作快速切换执行）。

3、PCB（进程控制块）

PCB是进程实体的一部分，是操作系统中最重要的记录性数据结构。它是进程管理和控制的最重要的数据结构，每一个进程均有一个PCB，在创建进程时，建立PCB，伴随进程运行的全过程，直到进程撤消而撤消。

PCB中记录了操作系统所需的，用于描述进程的当前情况以及控制进程运行的全部信息。

进程控制块是用来描述进程的当前状态，本身特性的数据结构，是进程中组成的最关键部分，其中含有描述进程信息和控制信息，是进程的集中特性反映，是操作系统对进程具体进行识别和控制的依据。

PCB一般包括：

1）程序ID（PID、进程句柄）：它是唯一的，一个进程都必须对应一个PID。PID一般是整形数字

2）特征信息：一般分系统进程、用户进程、或者内核进程等

3）进程状态：运行、就绪、阻塞，表示进程现的运行情况

4）优先级：表示获得CPU控制权的优先级大小

5）通信信息：进程之间的通信关系的反映，由于操作系统会提供通信信道

6）现场保护区：保护阻塞的进程

7）资源需求：分配控制信息

8）进程实体信息：指明程序路径和名称，进程数据在物理内存还是在交换分区（分页）中

9）其他信息：工作单位，工作区，文件信息等 

索引方式
同状态的PCB同样集中记录，但以索引表的方式记录PCB的地址。用专门的单元记录各索引表的首地址。

链接方式
同一状态的PCB，依靠链接指针链接成队列。就绪队列；若干个阻塞队列；空白队列（PCB区的空PCB块）

４、银行家算法

银行家算法是从当前状态出发，按照系统各类资源剩余量逐个检查各进程需要申请的资源量，找到一个各类资源申请量均小于等于系统剩余资源量的进程P1。然后分配给该P1进程所请求的资源，假定P1完成工作后归还其占有的所有资源，更新系统剩余资源状态并且移除进程列表中的P1，进而检查下一个能完成工作的客户，......。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。若找不到这样的安全序列，则当前状态不安全。

相关数据结构

(1)可利用资源向量Available。这是一个含有m个元素的数组，其中的而每一个元素代表一类可利用资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态的改变。如果Available[j]=K,则表示系统中现有Rj类资源K个。

(2)最大需求矩阵Max。这是一个n*m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K；则表示进程i需要Rj类资源的最大数目为K。

(3)分配矩阵Allocation。这也是一个n*m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K。

(4)需求矩阵Need。这也是一个n*m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K,则表示进程i还需要Rj类资源K个，方能完成任务。

上述三个矩阵间存在下述关系：Need[i,j]=Max[i,j]-Allocation[i,j]

#include<iostream>  
using namespace std;  
  
// p 进程数，r 资源种类  
#define p 4  
#define r 3  
 
//a-max,b-allocation,c-need,d-available  
void input(int arr[p][r],int brr[p][r],int crr[p][r],int drr[r])  
{  
    int i,j;  
    cout<<"* input max data:\n";  
    for(i=0;i<p;i++)
    { 
        for(j=0;j<r;j++)
        {   
            cin>>arr[i][j];  
        }
    }
    cout<<"* input allocation data:\n";  
    for(i=0;i<p;i++)  
    {
        for(j=0;j<r;j++)
        { 
            cin>>brr[i][j];  
        }
    }
    cout<<"* input need data:\n";  
    for(i=0;i<p;i++) 
    { 
        for(j=0;j<r;j++)
        {
            cin>>crr[i][j];  
        }
    }
    cout<<"* input available data:\n";  
    for(j=0;j<r;j++)
    {    
        cin>>drr[j];
    }  
}  
  
int com(int m[r],int n[r])  
{  
    int i,flag=0;  
    for(i=0;i<r;i++) 
    { 
        if(m[i]<n[i])  
        {  
            flag=1;  
            break;  
        } 
    } 
    if(flag==1) 
    {
        return(0);
    }  
    else return(1);  
}  
  
int stest(int brr[p][r],int crr[p][r],int drr[r])  
{  
    int i,j,k,l,flag=0,flag1=0;  
    int t[r],finish[p],dd[r];  
    for(i=0;i<p;i++)
    {
         finish[i]=0;//finish为1即表示available满足某一进程并让其实现  
    }
    for(i=0;i<r;i++)
    {
         dd[i]=drr[i];
    }  
    cout<<"分配序列：\n";  
    for(k=0;k<p;k++)            //全搜索，直至实现或不可能实现  
    {  
        for(i=0;i<p;i++)  
        {  
            if(finish[i]==1)
               continue;  
            else  
            {  
                for(j=0;j<r;j++)
                {
                    t[j]=c[i][j];
                }  
                if(com(dd,t))  
                {  
                    finish[i]=1;  
                    cout<<i+1<<'\t';  
                    flag=1;  
                    for(l=0;l<r;l++)
                    {
                        dd[l]=dd[l]+brr[i][l];
                    }  
                    break;  
                }  
            }  
            if(flag==1)
               break;  
        }     
    }  
    cout<<'\n';  
    for(l=0;l<p;l++)  
    {  
        //cout<<finish[l]<<endl;  
        if(finish[l]==0)
           flag1=1;  
    }  
        //cout<<flag1<<endl;  
    if(flag1==0)
       return(1);    //flag1为记录finish是否有0存在的标记，当flag1=0时，安全  
    else 
       return(0);  
}  

//req-request,n-第n个进程申请资源  
void rtest(int b[p][r],int c[p][r],int d[r],int req[r],int n)  
{  
    int i,j;  
    int t[r];  
    n=n-1;  
    for(i=0;i<r;i++)
    {
         t[i]=c[n][i];
    }  
    if(com(d,req)&&com(t,req))//对available，request进行比较  
    {  
        for(j=0;j<r;j++)  
        {  
            b[n][j]=b[n][j]+req[j];  
            c[n][j]=c[n][j]-req[j];  
            d[j]=d[j]-req[j];  
        }  
        if(stest(b,c,d))
        {
            cout<<"允许"<<n+1<<"个进程申请资源！\n";  
        }
        else   
        {  
            cout<<"不允许"<<n+1<<"个进程申请资源！\n";  
            cout<<"恢复以前状态！\n";  
            for(j=0;j<r;j++)  
            {  
                b[n][j]=b[n][j]-req[j];  
                c[n][j]=c[n][j]+req[j];  
                d[j]=d[j]+req[j];  
            }  
        }  
    }  
  
    else cout<<"申请资源量出错！\n";  
}  

void main()  
{  
    int j,n; //n-第n个资源申请  
    int max[p][r],allocation[p][r],need[p][r];  
    int available[r],request[r];  
    input(max,allocation,need,available);  
    if(stest(allocation,need,available)==1)
    {
        cout<<"初始状态安全！\n";  
    }
    else
    {
        cout<<"初始状态不安全！\n";  
    }
    cout<<" input request data:\n";  
    for(j=0;j<r;j++)
    {
        cin>>request[j]; 
    }
    cout<<"第n个进程申请资源——n的值\n";  
    cin>>n; 
    rtest(allocation,need,available,request,n);  
} 

5、操作系统使用的缓冲技术通过缓冲区实现,缓冲区有两块:高速缓存区（物理存在）和磁盘缓存区（逻辑存在，实际是内存一块），都不在外存（硬盘）

6、影响缺页中断率的因素

① 分配给作业的主存块数多则缺页率低，反之缺页中断率就高。

② 页面大，缺页中断率低；页面小缺页中断率高。

③ 程序编制方法。以数组运算为例，如果每一行元素存放在一页中，则按行处理各元素缺页中断率低；反之，按列处理各元素，则缺页中断率高。

④ 页面调度算法对缺页中断率影响很大，但不可能找到一种最佳算法。

7、实时操作系统（RTOS）

实时操作系统的调度算法是抢占式的，因为要保证对事件的实时响应，需要事件响应进程及时获得CPU时间，采用抢占式调度算法可以保证优先级高的进程可以暂停优先级低的进行而自身获取CPU时间。

8、普通用户通常使用逻辑地址，操作系统会映射为物理地址，对用户透明

9、某计算机系统中有8台打印机，由K个进程竞争使用，每个进程最多需要3台打印机。该系统可能会发生死锁的K的最小值是

由于每个进程最多需要使用3台打印机，可以先给每个进程分配2台打印机，最后在总的资源中减1个出来分配给一个进程就能避免死锁。所以用7/2=3.5,向下取整为3，所以最多使用3个进程不会发生死锁。所以发生死锁的最小值为4。

10、通道

通道是一个特殊功能的处理器，它有自己的指令和程序专门负责数据输入输出的传输控制，而CPU将“传输控制”的功能下放给通道后只负责“数据处理”功能。这样．通道与CPU分时使用内存，实现了CPU内部运算与I/O设备的平行工作。控制内存和外设。

11、SPOOLing技术

SPOOLING （即外部设备联机并行操作），即Simultaneous Peripheral Operations On-Line的缩写，它是关于慢速字符设备如何与计算机主机交换信息的一种技术，通常称为“假脱机技术”。

SPOOLing技术实际上是一种外围设备同时联机操作技术,又称为排队转储技术。它在输入和输出之间增加了“输入井”和“输出井”的排队转储环节。

特点：

(1)提高了I/O速度.从对低速I/O设备进行的I/O操作变为对输入井或输出井的操作,如同脱机操作一样,提高了I/O速度,缓和了CPU与低速I/O设备速度不匹配的矛盾。
(2)设备并没有分配给任何进程.在输入井或输出井中,分配给进程的是一存储区和建立一张I/O请求表。
(3)实现了虚拟设备功能.多个进程同时使用一独享设备,而对每一进程而言,都认为自己独占这一设备,不过,该设备是逻辑上的设备。