银行家算法
   
    考虑下面的系统快照:
    
    
    
    回答以下问题:
    
    1.计算需求矩阵Need.
    
    2.此状态是否为安全状态,如果是,则找出安全序列.
    
    3.在此基础上P1 申请(0,4,2,0)能否立即分配?为什么?
    
    
     【解答】
     
     1.这里的最大需求量矩阵我们把它命名为Max,把已分配的资源矩阵命名为Allocation,第一问的需求矩阵Need = Max – Allocation =
     
     
      
       
        
         A 
B
C
D
P
0
0
0
0
0
P
1
0
7
5
0
P
2
1
0
0
2
P
3
0
0
2
0
P
4
0
6
4
2
          \begin{matrix} & A & B& C & D\\ P0& 0 & 0 & 0 & 0\\ P1 & 0& 7 & 5 & 0 \\ P2& 1 & 0 & 0 & 2\\ P3&0&0&2&0\\ P4&0&6&4&2 \end{matrix}
        
        
         
          
          
          
           
            
             
              
               
                
                 
                 
                 
                 
                
                
                 
                 
                 
                  
                   P
                  
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   P
                  
                  
                   1
                  
                 
                
                
                 
                 
                 
                  
                   P
                  
                  
                   2
                  
                 
                
                
                 
                 
                 
                  
                   P
                  
                  
                   3
                  
                 
                
                
                 
                 
                 
                  
                   P
                  
                  
                   4
                  
                 
                
               
               
                
               
              
              
               
                
                
               
              
             
            
            
            
            
            
            
             
              
               
                
                 
                 
                 
                  
                   A
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   1
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
               
               
                
               
              
              
               
                
                
               
              
             
            
            
            
            
            
            
             
              
               
                
                 
                 
                 
                  
                   B
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   7
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   6
                  
                 
                
               
               
                
               
              
              
               
                
                
               
              
             
            
            
            
            
            
            
             
              
               
                
                 
                 
                 
                  
                   C
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   5
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   2
                  
                 
                
                
                 
                 
                 
                  
                   4
                  
                 
                
               
               
                
               
              
              
               
                
                
               
              
             
            
            
            
            
            
            
             
              
               
                
                 
                 
                 
                  
                   D
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   2
                  
                 
                
                
                 
                 
                 
                  
                   0
                  
                 
                
                
                 
                 
                 
                  
                   2
                  
                 
                
               
               
                
               
              
              
               
                
                
               
              
             
            
           
          
         
        
       
      
     
     
     2.安全状态就是每一项都能正常合理分配的状态,所以这里第一步:
     
     令Work = Available = (1,5,2,0),Finish[i] = false;
     
     先分配给P0, then Work = (1,5,3,2),Finish[0] = true;
     
     然后分配给P2,then Work = (2,8,8,6),Finish[2] = true;
     
     然后分配给P1,then Work = (3,8,8,6),Finish[1] = true;
     
     然后分配给P3,then Work = (3,14,11,8),Finish[3] = true;
     
     然后分配给P4,then Work = (3,14,12,12),FInish[4] = true;
     
     
      因为一直都是true,所以{P0,P2,P1,P3,P4}是一个安全序列,当然,安全序列并不是唯一的,一般都是按照顺序一步一步找出来的。
     
     
     3.P1立即请求(0,4,2,0),
     
     首先需要进行两步判断:
    
   
- 
     
 请求向量是否小于A的Max
 
- 
     
 请求向量是否小于Available
 
    
     这里我们能看出(0,4,2,0)<(1,7,5,0),同时(0,4,2,0)<(1,5,2,0)
     
     假设可以立即分配,
     
     令Work = Available =(1,1,0,0)Finish [i] = false;
     
     先分配给P0, then Work = (1,1,1,2),Finish[0] = true;
     
     然后分配给P2, then Work = (2,4,6,6),Finish[2] = true;
     
     然后分配给P1, then Work =(3,8,8,6),Finish[1] = true;
     
     然后分配给P3, then Work =(3,14,11,8),Finish[3] = true;
     
     最后分配给P4, then Work =(3,14,12,12),Finish[4] =true;
     
     
      所以{P0,P2,P1,P3,P4}是一个安全序列,也并不唯一
     
    
   
    
    
    分段地址变换
   
    已知段表和以下逻辑地址,请计算相应的物理地址:
    
    a.< 0 , 430 >
    
    b.< 1 , 10 >
    
    c.< 2 , 500 >
    
    d.< 3 , 400 >
    
    e.< 4 , 112 >
   
| 段号 | 基址 | 长度 | 保护 | 
|---|---|---|---|
| 0 | 219 | 600 | R | 
| 1 | 2300 | 14 | R/W | 
| 2 | 90 | 100 | R/W | 
| 3 | 1327 | 580 | R | 
| 4 | 1952 | 96 | R | 
    
     【解答】
     
     对a来说,段号为0,430<600,物理地址为430+219= 649
     
     对b来说,段号为1,10<14,物理地址为2300+10 = 2310
     
     对c来说,段号为2,500>100,所以发生越界中断
     
     对d来说,段号为3,400<580,物理地址为1327+400 =1727
     
     对e来说,段号为4,112>96,所以发生越界中断
     
     
      【总结】
      
      这种题没有啥难的,主要就是用所给的逻辑地址和各段的段长进行比较。
      
      
       本文到此结束,欢迎大家在评论区探讨~~~
      
     
    
   
 
