opration.java

注意: 1. OS.jar为Java打包可执行文件 2. 由于时间,和界面空间问题,每个进程的资源拥有情况没有详细列明.如果要认真检查 程序的正确性,可以重新编译运行,然后查看Dos界 面下的输出.因

import java.io.*;
import java.util.Timer; 
import java.util.TimerTask; 
import java.util.Calendar;  
import java.awt.*;
import java.awt.event.*;
import javax.swing.*; 

class ReSource extends TimerTask 
{ private int[] Work,Available;
  private int N=100,M=20,I=0,J=0,k,maxRS,sign=0;  //N为原设定最大进程数,M为最大资源数
  private boolean[] Finish;     
  public Queue Que;           //进程队列
  private ProcessLook look;   //界面
  private static int Time=0,PN;
  private static int Control=0; 
  
  
   public ReSource()      //构造函数
  {  int i,j; 
     k=0;
     I=0;
     maxRS=20; 
     Available=new int[M];
     Work=new int[M];
     Finish=new boolean[N]; 
     Que=new Queue();
     look= new ProcessLook(); 
     for(j=0;j<M;j++)     //初始化可用资源资源数目    
      { Available[j]=maxRS;
   	    Work[j]=maxRS;
      }   
     for(i=0;i<N;i++)    //随机生成新进程加入进程队列
      { Process P=new Process(); 
      	Que.InQueue(P); 
      } 
   }
  
  public void setdisable()    
  { look.StartDisable(); 
  }
  
  public int QueueLength()    //获取进程队列长度
  { return(Que.QueueLength);
  }
   
   public void assignRequest(Request Q)  //分配请求
   { int RN=Q.ResourceNumber,PN=Q.Pnumber;
     Available[RN]=Available[RN]-Q.Request; 
   	 Que.ProQueue[PN].Allocation[RN]=Que.ProQueue[PN].Allocation[RN]+Q.Request; 
   	 Que.ProQueue[PN].Need[RN]=Que.ProQueue[PN].Need[RN]-Q.Request;
   }
   
   public void disassign(Request Q)   //撤销分配
   {int RN=Q.ResourceNumber,PN=Q.Pnumber;
        Available[RN]=Available[RN]+Q.Request;  
   	    Que.ProQueue[PN].Allocation[RN]=Que.ProQueue[PN].Allocation[RN]-Q.Request; 
   	    Que.ProQueue[PN].Need[RN]=Que.ProQueue[PN].Need[RN]+Q.Request;
   }
   
  public boolean isSafe()      //安全性检测
   {  int sign=0,mark=0;
       for(int j=0;j<M;j++)    //初始化Work=Available    
            Work[j]=Available[j];   
       for(int i=0;i<Que.QueueLength;i++)
            Finish[i]=false;  //初始化Finish[i]=false  
       
       for(int k=0;k<Que.QueueLength;k++)    //扫描n次
          {   sign=0;                      //从新设定标志 
              for(int i=0;i<Que.QueueLength;i++)
                 {  if(Finish[i]==false)  //这里i表示进程号
                     {   for(int j=0;j<M;j++)
                           {  if(Que.ProQueue[i].Need[j]>Work[j])
                   	            { sign=1;  //sign=1表示需求大于可用
                   	              break; 
                   	            } 
                            }
                        if(sign==0)   //sign=0 表示该进程需求小于可用,可以完成
                          { for(int j=0;j<M;j++)
                              { Work[j]=Work[j]+Que.ProQueue[i].Allocation[j]; 
                               } 
                            Finish[i]=true;     //i可表示为安全序列
                            System.out.println("      安全序列     :进程"+Que.ProQueue[i].ProcessNumber+"可以 完成");
                            break;              //从新下一次扫描 
                          } 
                        sign=0;
                     }  
                 } 
         } 
      for(int i=0;i<Que.QueueLength;i++)   //检查是否全部进程可以完成 
        { if(Finish[i]!=true)
            { mark=1; break;}
        } 
       if(mark==1)  
          return false;
       else return true; 
   }
    
   
   public String bankerAssign(Request Q)   //银行家算法
   {  if(Q.Request>Que.ProQueue[Q.Pnumber].Need[Q.ResourceNumber])
            return("申请数大于申报数"); 
      else if(Q.Request>Available[Q.ResourceNumber])
            return("申请数大于目前资源可用数,waiting"); 
      else { assignRequest(Q);            //试探性分配 
             if(!this.isSafe())
                { disassign(Q);            //不安全安全则不分配 
                  return("分配则进入不安全状态");
                }
             else   return("安全分配"); 
            }
   }
   
   public void displayAttribute()        //显示队列状态
   {  for(int i=0;i<Que.QueueLength;i++)
       { 
         for(int j=0;j<M;j++)
         { System.out.print("进程"+Que.ProQueue[i].ProcessNumber+" 共需要 "+j+"类资源"+ Que.ProQueue[i].Max[j]+" 个\t"); 
       	   System.out.print("已分配 "+j+"类资源"+ Que.ProQueue[i].Allocation[j]+" 个\t");
       	   System.out.println("尚  差 "+j+"类资源"+ Que.ProQueue[i].Need[j]+" 个"); 
         } 
       }  
   } 
   
   public boolean isFinish(Process P)   //检查进程是否完成
   {  int mak=0;
    for(int i=0;i<M;i++)
      { if(P.Need[i]!=0)
          {mak=1;break;}
      }
      if(mak==0)
         return true;
      else return false; 
   } 
   
   public void finishAndQuit()     //进程完成就出队
   { int k;
   	k= Que.QueueLength;
       for(int i=0;i<k;i++)
       { if(this.isFinish(Que.ProQueue[i]))
            {   for(int j=0;j<M;j++) 
                   this.Available[j]=this.Available[j]+Que.ProQueue[i].Allocation[j];//出队前归还资源 
               
               Que.OutQueue(i);    //进程完成就出队
               break;
            }
       	}  
       	if(Que.QueueLength==0)
       	  {
       	  	 System.out.println("\n\n\n所有进程运行完毕\n\n"); 
       	     look.quitList("   所有进程运行完毕  "); 
       	  }  
   } 
   
    public void finishAndQuit(int PNo)   //检查队列中编号为PNo的进程是否完成,完成则出队
   {   if(this.isFinish(Que.ProQueue[PNo]))
            {   for(int j=0;j<M;j++) 
                   this.Available[j]=this.Available[j]+Que.ProQueue[PNo].Allocation[j];//出队前归还资源  
               look.quitList(" 进   程   "+ Que.ProQueue[PNo].ProcessNumber+"  出队 ");
               Que.OutQueue(PNo); 
            }
         
       	if(Que.QueueLength==0)
       	  {  System.out.println("\n\n\n所有进程运行完毕\n\n"); 
       	  	 look.quitList("   所有进程运行完毕  ");  
       	  }  
   }  
   
  public void run()
  { int i,j=0,k; 
      sign=0; 
      
    if(Que.QueueLength!=0 && this.Control==1)     //Control 控制开始与停止 为1 时开始,0时停止
    { for(int x=0;x<N*4;x++)                      //随机申请4*N次
       {int pn=(int)(java.lang.Math.random()*Que.QueueLength);  //随机生成进程队列编号
        int rn=(int)(java.lang.Math.random()*M);  // 随机生成资源号
        while(this.Available[rn]==0)
        { rn=(int)(java.lang.Math.random()*M);
        } 
        
        
       int r=Que.ProQueue[pn].Need[rn]/2+1;  //申请个数
       Request RQ=new Request(pn,rn,r);
       System.out.println(" 进程"+Que.ProQueue[pn].ProcessNumber+" 申请 "+rn+"类资源"+ r+" 个");
       bankerAssign(RQ);      //执行安全性算法
       finishAndQuit(pn);     //检查进程是否完成  
       if(Que.QueueLength==0)
          break; 
     }  
  
      displayAttribute();   //显示系统分配情况 
      Time=Time+3;          //用于计时
      
      
      String ProMessage[]=new String[Que.QueueLength];
     for(i=0;i<Que.QueueLength;i++)
     {
      ProMessage[i]=new String("进程"+Que.ProQueue[i].ProcessNumber+"在队列中"); 
     }
     look.SetProcessList(ProMessage);  //在窗口显示现存进程   
      
      
      String Str[]=new String[M];
      for(i=0;i<M;i++)
      { Str[i]=new String("系统还有 "+Integer.toString(i)+" 号资源 "+Integer.toString(Available[i])+" 个");
       }
      
     look.SetList(Str);   //在窗口显示现有资源情况
     look.Result("  目前还要"+Que.QueueLength+" 个进程没有完成, 已用时"+Time+"秒");  
     }  
  } 
   
  
  class Queue   //进程队列类
  { Process ProQueue[];
   
    int QueueLength=0,ReQueueLength=0;
    public Queue()
    {   QueueLength=0;
    	ProQueue=new Process[N]; 
    
    }
    
    public void InQueue(Process P)  //入队
    { ProQueue[QueueLength]=P; 
      QueueLength++;
      System.out.println("  QueueLength="+QueueLength); 
    } 
     
    public void OutQueue(int IP)   //出队
    {
      if(IP!=QueueLength)
        { QueueLength--;
          for(int i=IP;i<QueueLength;i++)
           { ProQueue[i]=ProQueue[i+1];	
           }
        }
      else 
        { QueueLength--;	
        }
    } 
    
 } 
   
  class Process   //进程类
  { public int Require[],Max[],Allocation[],Need[];
    public  String Pname;
    public int ProcessNumber;
    public boolean finish;
     public Process()
     { ProcessNumber=PN++;  
       Max=new int[M];
       Allocation=new int[M];
       Need=new int[M]; 
     	for(int i=0;i<M;i++)
     	{   Max[i]=(int)(java.lang.Math.random()*(maxRS/2+1));  //初始化进程所需i类资源的最大值 
            Need[i]=Max[i]-Allocation[i]; 
     	} 
     } 
  } 
   
  class Request         //请求类
  { int Pnumber;        //进程在队列的编号
    int ResourceNumber; //资源号
    int Request;        //请求数
    public Request()       
    {}
    public Request(int pn,int rn,int r)
    { this.Pnumber=pn;            
      this.ResourceNumber=rn;
      this.Request=r; 
    }
  }  
   
   //界面类,    以下用于界面显示
   
  class ProcessLook extends JFrame implements ActionListener     
{  private JTextField ProcessNumber,ResourceNumber,RequestNumber; 
   private JButton addRequest,Start,SetResource,ReStart;
   private JMenuBar menuBar;
   private JMenu fileMenu,typeMenu;   //定义菜单	
   private JPanel ListPanel,KeyPanel,TextPanel;  //定义三个面板	
   private JLabel Plabel,Rlabel,rlabel,Pnumber,Rnumber;
   private JList ResourceList,ProcessList;	
   private JTextField Result,quitList,request,PNo,RNo;	
   private Font font = new Font("Dialog",Font.PLAIN,14); 
   private int Con=0;
	
	public ProcessLook()
	{ super("银行家算法－－骆子丞");
	  Container pane = getContentPane();    //定义容器并
      pane.setLayout(new BorderLayout());   //设置为边界布局	
	 	
     initTextPanel();	
	 initListPanel();
	 initKeyPanel();  
	
	pane.add(TextPanel,BorderLayout.NORTH); //文本框在北面	
 	pane.add(KeyPanel,BorderLayout.CENTER);
 	pane.add(ListPanel,BorderLayout.SOUTH);
	
	this.setResizable(false);
	createMenu();	
	setSize(540,450);	
	setVisible(true);  
	}  
	
	public void actionPerformed(ActionEvent e)
	 { int kk=0;