banker.java

采用java语言实现的模拟银行家算法

//banker.java
//os program banker_arithmetic
package com.exp.os;
import com.exp.os.banker2;

//java core package
import java.awt.*;
import java.awt.event.*;

//java extension package
import javax.swing.*;

public class banker extends JFrame{

	private JPanel panel1,panel2,panel3,panel4,panel5,panel6,panel7,panel8,panel9,panel10,panel11;
	private JTextField text1,text2,text3,text4,text5,text6,text7,text8,text9,text10,text11;
	private JButton button1,button2,button3,button4,button5,button6,button7,button8;
	private JLabel label1,label2,label3,label4,label5,label6,label7,label8,label9,label10,label11,label12,label13,label14,label15;	
	private String output1,output2,output3;//依次为：所需资源，已分配资源，系统所用资源
	private process pro1,pro2;
	private int row=0,col=0;
	private int u=0,a=0;//系统最初可用资源输入时 的计数器,u的作用和m的作用一样
	private int m=0,n=0,t=1;//输入进程信息时，m为进程计数器，n为资源计数器,t记录同一个进程的资源是否输完了
	private int b=0,q=1;//输入进程申请信息时，记录资源的计数器,q的作用和t的作用是一样的
	private int R[]=new int[10];//记录申请的资源
	private String Sname;//要申请资源的进程名
	private int safe[]=new int[10],se=0;//存放安全序列的叔祖,se为记录数组的下表，safe[]的下表是几就表示是第几个完成的

	public banker()
	{
		super( "银行家算法" );
		Container container=getContentPane();
	        container.setLayout( new GridLayout(4,1) );
		//Container container2=getContentPane();//企图产生两个窗体,结果是失败了
		//container2.setLayout( new GridLayout(1,1) );
		ActionEventHandler handler=new ActionEventHandler ();
		
		//initialize
		panel1=new JPanel();
  		panel1.setLayout( new FlowLayout( FlowLayout.LEADING) );
		panel2=new JPanel();
  		panel2.setLayout( new FlowLayout(FlowLayout.LEADING) );
		panel3=new JPanel();
  		panel3.setLayout( new GridLayout(3,1) );
		panel4=new JPanel();
  		panel4.setLayout( new GridLayout(2,1) );
		panel5=new JPanel();
  		panel5.setLayout( new FlowLayout(FlowLayout.LEADING) );
		panel6=new JPanel();
  		panel6.setLayout( new FlowLayout(FlowLayout.LEADING) );
		panel7=new JPanel();
  		panel7.setLayout( new FlowLayout(FlowLayout.LEADING) );
		panel8=new JPanel();
  		panel8.setLayout( new FlowLayout(FlowLayout.LEADING) );
		panel9=new JPanel();
  		panel9.setLayout( new FlowLayout(FlowLayout.LEADING) );
		panel10=new JPanel();
  		panel10.setLayout( new GridLayout(3,1) );
		panel11=new JPanel();
  		panel11.setLayout( new GridLayout(2,1) );

		text1=new JTextField(10);
		text2=new JTextField(10);
		text3=new JTextField(10);
		text4=new JTextField(10);
		text5=new JTextField(10);
		text6=new JTextField(10);
		text7=new JTextField(10);
		text8=new JTextField(10);
		text9=new JTextField(10);
		text10=new JTextField(10);
		text11=new JTextField(10);

		button1=new JButton( "OK" );
		button1.addActionListener( handler );
		button2=new JButton( "OK" );
		button2.addActionListener( handler );
		button3=new JButton( "OK" );
		button3.addActionListener( handler );
		button4=new JButton( "OK" );
		button4.addActionListener( handler );
		button5=new JButton( "开始" );
		button5.addActionListener( handler );
		button6=new JButton( "资源信息" );
		button6.addActionListener( handler );
		button7=new JButton( "刷新" );
		button7.addActionListener( handler );
		button8=new JButton( "实践分配" );
		button8.addActionListener( handler );

		label1=new JLabel( "进程总数" );
		label2=new JLabel( "资源总数" );
		label3=new JLabel( "资源序号" );
		label4=new JLabel( "资源" );
		label5=new JLabel( "进程名" );
		label6=new JLabel( "资源序号" );
		label7=new JLabel( "进程名:" );
		label8=new JLabel( "已分配的资源:" );
		label9=new JLabel( "尚需的资源:" );
		label10=new JLabel( "进程名:" );
		label11=new JLabel( "资源:" );
		label12=new JLabel( "进程发出请求:" );
		label13=new JLabel( "输入进程信息:" );
		label14=new JLabel( "状态栏" );	
		label15=new JLabel( "系统最初可用资源:" );

		//add compent to panel
		panel1.add( label1 );
		panel1.add( text1 );
		panel1.add( label2 );
		panel1.add( text2 );
		panel1.add( button1 );

		panel2.add( label3 );
		panel2.add( text3 );
		panel2.add( label4 );
		panel2.add( text4 );
		panel2.add( button2 );
	 	panel10.add( panel1 );
		panel10.add( label15);
		panel10.add( panel2 );

		panel7.add( label5 );
		panel7.add( text5 );
		panel7.add( label6 );
		panel7.add( text6 );
		panel8.add( label7 );
		panel8.add( text7 );
		panel8.add( label8 );
		panel8.add( text8 );
		panel8.add( label9 );
		panel8.add( text9 );
		panel8.add( button3 );

		panel3.add( label13 );
		panel3.add(panel7);
		panel3.add(panel8);

		panel9.add( label10 );
		panel9.add( text10 );
		panel9.add( label11 );
		panel9.add( text11 );
		panel9.add( button4 );
		panel4.add( label12 );
		panel4.add( panel9 );

		panel5.add( button5 );
		panel5.add( button6 );
		panel5.add( button7 );
		panel5.add( button8 );

		panel6.add( label14 );
		panel11.add( panel5 );
		panel11.add( panel6 );
		

		container.add( panel10 );
		container.add( panel3 );
		container.add( panel4 );
		container.add( panel11 );

		//panel6.setEnabled( false );
		//panel7.setEnabled( false );
		text1.setEnabled( false );//禁用所有编辑框
		text2.setEnabled( false );
		text3.setEnabled( false );
		text4.setEnabled( false );
		text5.setEnabled( false );
		text6.setEnabled( false );
		text7.setEnabled( false );
		text8.setEnabled( false );
		text9.setEnabled( false );
		text10.setEnabled( false );
		text11.setEnabled( false );
		button1.setEnabled( false );
		button2.setEnabled( false );
		button3.setEnabled( false );
		button4.setEnabled( false );
		button8.setEnabled( false );
		button6.setEnabled( false );
	}//end method banker

	public static void main( String args[] )
	{
	//	try{
		banker dhn =new banker ();
		dhn.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

		dhn.setSize( 670,420 );
		dhn.setVisible( true );
	//	}
	//	catch( Exception )
	//	{
		//JOptionPane.showMessageDialog(null,"warning","dhn",JOptionPane.INFORMATION_MESSAGE);	
	//	}
	}//end method main

	private class ActionEventHandler implements ActionListener
	{
	public void actionPerformed( ActionEvent event )
	{
	if(event.getSource()==button6)
	{
			banker2 wm =new banker2();
		wm.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		wm.setSize( 400,500 );
		wm.setVisible( true );
		//output1="dhn\ndhn\ndhn\ndhn\n";
		output2="尚需资源\n"+"进程\t资源...\n";
		output1="已分配资源\n"+"进程\t资源...\n";
		output3="系统已有资源\n"+"资源名\t资源...\n";
		output2=pro1.printS(output2);
		output1=pro1.printF(output1);
		output3=pro1.printA(output3);
		wm.outPutNeed( output1 );//已分配资源
		wm.outPutAllocation( output2);//尚需资源
		wm.outPutAvailable( output3 );//系统已有资源
	
	}
	if( event.getSource()==button1 )//输入进程数目和资源数目
	{
		button6.setEnabled( true );//因为只有按了button1之后才创建了进程对象pro1,而在创建pro1之前不能点击资源信息按钮//，否则会出现问题，所以在电击button1之前得让button6为不可用		
		if( Integer.parseInt(text1.getText())<10||Integer.parseInt(text2.getText())<10)
		{
			row=Integer.parseInt(text1.getText());
			col=Integer.parseInt(text2.getText());
		        pro1=new process( row,col );
			//text3.setEnabled( true );
		        text4.setEnabled( true );
			text3.setText( "资源"+1 );
			button2.setEnabled( true );
			button1.setEnabled( false );
		        text1.setEnabled( false);
		        text2.setEnabled( false );
		}
		else{
		JOptionPane.showMessageDialog(null,"您输入的数字有误，请重新输入","dhn",JOptionPane.INFORMATION_MESSAGE);
		}
			//text3.setEnabled( false );//输入完之后，就禁用输入框
		       // text4.setEnabled( false );

	}//if button1
	if( event.getSource()==button5 )//开始按钮
	{
			text1.setEnabled( true );//开始后，就使进程数目和资源树木编辑框可一使用
			text2.setEnabled( true );
			button1.setEnabled( true );
	}
	if( event.getSource()==button2 )//输入系统最初所有的资源信息
	{
		if( a<col )//记录现在输入了多少个资源，如果输入的资源朝过了拥护输入的资源数目就终止输入
		{
			pro1.setA(a,Integer.parseInt(text4.getText()));
			a++;
			//测试需要
			JOptionPane.showMessageDialog(null,"刚输入的资源:"+pro1.getA(a-1)+"\n"+col,"dhn",JOptionPane.INFORMATION_MESSAGE);	
			if(a!=col)
			{
				text3.setText("进程"+(a+1));
			}
		}
		if(a==col)
		{
			JOptionPane.showMessageDialog(null,"次进程的资源输入完毕，您可以输入进程信息了","dhn",JOptionPane.INFORMATION_MESSAGE);	
			text3.setText("");
			text4.setEnabled( false );//资源输入完毕后，就将输入资源的编辑框设置为，不可用
			text7.setEnabled( true );//资源输入完之后 就将资源信息的输入框都可以使用了
			text8.setEnabled( true );
			text9.setEnabled( true );
			button2.setEnabled( false );
			button3.setEnabled( true );

			text5.setText( "进程"+1 );
			text6.setText( "资源"+1 );
		}
		text4.setText("");//每输入完一个资源编辑框就置空
	}//if button2

	if( event.getSource()==button3 )//输入各个进程的资源信息
	{
		if( m<row )
		{
			if(t==1)//表示给另一个进程输入资源
			{
				pro1.setName( text7.getText(),m );//将输入的进程名送到进程对象里
				text7.setEnabled(false);//在同一个进程内使进程名输入框为禁用	
			}
			if( n<col )
			{
				pro1.setS( Integer.parseInt(text9.getText()),m,n );//给S[m][n]添加尚需资源
				pro1.setF( Integer.parseInt(text8.getText()),m,n );//给F[m][n]添加已分配的资源
				//测试需要
				JOptionPane.showMessageDialog(null,"刚输入的尚需资源"+pro1.getS(m,n)+"\n"+n,"dhn",JOptionPane.INFORMATION_MESSAGE);	
				
				text8.setText("");//当要输入下一次资源时，将资源输入框设置成空
				text9.setText("");
				n++;//资源计数器加1
				t=0;
				if(n!=col)
				{
				text6.setText( "资源"+(n+1) );
				}
				 if(n==col)
				{
					n=0;
					text6.setText( "资源"+(n+1) );

					//测试需要
					JOptionPane.showMessageDialog(null,"上一个进程的名字 "+pro1.getName(m)+m,"dhn",JOptionPane.INFORMATION_MESSAGE);	

				    	m++;//进程计数器加1
					text5.setText( "进程"+(m+1) );
					t=1;//进入下一个进程输入
					text7.setEnabled(true);//当要输入下一个进程名字时，就将编辑框设置为可用
					text7.setText("");//当要输入下一个进程时，将进程名输入框设置成空

				}

			}
		}
		if(m==row)
		{
			JOptionPane.showMessageDialog(null,"进程资源输入完毕，您可以选择要申请的进程了","dhn",JOptionPane.INFORMATION_MESSAGE);	
			text10.setEnabled( true );//申请输入框可以使用
			text11.setEnabled( true );
			button4.setEnabled( true );
			text7.setEnabled( false );//进程信息输入框不可使用
			text8.setEnabled( false );
			text9.setEnabled( false );
			button3.setEnabled( false );			

		}
	}//if button3

	if( event.getSource()==button4 )//输入申请信息
	{
		int dh=0;
		dh=pro1.findName(text10.getText());
	   if(dh!=-1){
		if(t==1) 
		{
			Sname=text10.getText();
			text10.setEnabled(false);
		}
	//测试需要
JOptionPane.showMessageDialog(null,Sname,"dhn",JOptionPane.INFORMATION_MESSAGE);	
 		if( b<col )//记录现在输入了多少个资源，如果输入的资源朝过了拥护输入的资源数目就终止输入
		{
			R[b]=Integer.parseInt( text11.getText() );
JOptionPane.showMessageDialog(null,"刚输入的资源："+R[b]+"\n"+col,"dhn",JOptionPane.INFORMATION_MESSAGE);
			text11.setText( "" );	
			b++;
			t=0;
		}
		if(b==col)
		{
			t=1;
			JOptionPane.showMessageDialog(null,"申请信息输入完毕，现在可以测试了","dhn",JOptionPane.INFORMATION_MESSAGE);	
			//text10.setEnabled( false );
			//text11.setEnabled( false );
			//button4.setEnabled( false );
			button8.setEnabled( true );//测试按钮可以使用
		}
       	   }
	   else{
		JOptionPane.showMessageDialog(null,"没有此人信息","dhn",JOptionPane.INFORMATION_MESSAGE);	
		}
	}//if button4

	if( event.getSource()==button7 )
	{
		a=0;
		m=0;
		n=0;
		b=0;
		button1.setEnabled( true );
		text1.setEnabled( true );
		text2.setEnabled( true );
		se=0;
	}
		
	if( event.getSource()==button8 )
	{
		int xia=0;
		//pro1.clearOver();//清空完成数组
			//JOptionPane.showMessageDialog(null,"晴空完成数据","dhn",JOptionPane.INFORMATION_MESSAGE);	
		xia=pro1.findName( Sname );//*********
JOptionPane.showMessageDialog(null,"下标"+xia,"dhn",JOptionPane.INFORMATION_MESSAGE);
		if(isRlessThan( pro1.getProcess_S(xia) ))//************************
		{
JOptionPane.showMessageDialog(null,"R小于S","dhn",JOptionPane.INFORMATION_MESSAGE);

			if(isRlessThan( pro1.getProcess_A() ))//Ri<A?如果小于则返回1，否则返回0
			{

JOptionPane.showMessageDialog(null,"R小于A","dhn",JOptionPane.INFORMATION_MESSAGE);
				giveResource(pro1,xia,R);//给进程pro 的xia进程分配资源R
JOptionPane.showMessageDialog(null,"申请给进程"+xia+"分配资源","dhn",JOptionPane.INFORMATION_MESSAGE);
				pro2=new process( pro1,row,col);//创建测试进程对象
JOptionPane.showMessageDialog(null,"创建pro2成功"+pro2.getName(0),"dhn",JOptionPane.INFORMATION_MESSAGE);
				if(!isSafe(pro2))//如果安全则返回1************************
				{

JOptionPane.showMessageDialog(null,"系统是不安全的~~~~","dhn",JOptionPane.INFORMATION_MESSAGE);
					goBack( pro1 ,xia);//将进程pro1的操作取消//***************