experiment1.java

用JAVA实现的操作系统中

import java.awt.*;
import java.awt.event.*;
import java.util.*;
class Process
   {
      int length,num;
      Process()
         {}
      Process(int length,int num)
         {
            this.length=length;
            this.num=num;
         }  
   }
class Canvasoutput extends Canvas
   {
      int num;
      Canvasoutput(int num,int numall)
         {
            this.num=num;
            setSize(100+50*numall,50+60*num);
         }
      public void firstpaint(Graphics g)
         {
                  for(int i=0;i<num;i++)
                     {
                        g.drawString((i+1)+"号进程",20,50+i*60);
                     }
         }
      public void nextpaint(Graphics g1,int x,int yournum)
         {
             for(int i=0;i<=50;i++)
                {
                   g1.drawLine(80+50*x,50+60*yournum,i+50*x+80,50+60*yournum);  
                                  try
                                        {
                                            Thread.sleep(20);
                                        }
                                    catch(InterruptedException e1){} 
                }
         }
   }
class ProcessDialog extends Dialog
   {
       Canvasoutput canvasoutput;
       int yournum;
       int x;
       int num;
       ProcessDialog(Frame f,String s,boolean b,int num,int numall)
          {
             super(f,s,b);
             this.num=num;
             canvasoutput=new Canvasoutput(num,numall);
             add(canvasoutput);
             setBounds(0,0,100+50*numall,70+60*num);
             addWindowListener(new WindowAdapter()
               {
                  public void windowClosing(WindowEvent e)
                     {
                        setVisible(false);
                     }
               });  
          }
   }
class ProcessFrame extends Frame implements ActionListener
   {
      Button okbutton,spfbutton,rrbutton;
      TextArea text;
      TextField textinput;
      Label label;
      int num;
      int nummax,numall;
      GridBagLayout grid;
      GridBagConstraints c;
      Process process[]=new Process[10];
      ProcessFrame(String s)
         {
            super(s);
            grid=new GridBagLayout();
            c=new GridBagConstraints();
            setLayout(grid);
            num=0;
            nummax=0;
            okbutton=new Button("打入进程");
            rrbutton=new Button("用时间片轮转算法运行");
            spfbutton=new Button("用短进程优先算法运行");
            text=new TextArea(10,67);
            text.setEditable(false);
            textinput=new TextField(1);
            label=new Label("请输入"+(num+1)+"号进程的长度");
            setBounds(400,400,600,300);
            setVisible(true);
            okbutton.addActionListener(this);
            rrbutton.addActionListener(this);
            spfbutton.addActionListener(this);
            addComponent(label,0,0,2,1);    
            addComponent(textinput,0,2,1,1);    
            addComponent(okbutton,0,3,1,1); 
            addComponent(rrbutton,0,4,2,1);  
            addComponent(spfbutton,0,6,2,1);    
            addComponent(text,1,0,8,5);   
            addWindowListener(new WindowAdapter()
               {
                  public void windowClosing(WindowEvent e)
                     {
                        System.exit(0);
                     }
               });  
            validate();
         }
      private void addComponent(Component component,int row,int column,int width,int hight)
         {
            c.gridx=column;
            c.gridy=row;
            c.gridwidth=width;
            c.gridheight=hight;
            grid.setConstraints(component,c);
            add(component);
         } 
      public void actionPerformed(ActionEvent e)
         {
            if(e.getSource()==okbutton)
               {
                  String lengthstring=textinput.getText();
                  int length=Integer.parseInt(lengthstring);
                  process[num]=new Process(length,num+1);
                  textinput.setText(null);
                  text.append("已打入"+(num+1)+"号进程，其长度为："+process[num].length+"\n");
                  num++;
                  label.setText("请输入"+(num+1)+"号进程的内容");
                  nummax=process[0].length;
                  numall=process[0].length;
                  for(int j=1;j<num;j++)
                     {
                        numall=numall+process[j].length;
                        if(nummax<process[j].length)
                           {
                              nummax=process[j].length;
                           }
                     }
               }
             if(e.getSource()==spfbutton)
                {
                   text.append("\n用短进程优先算法运行\n");
                   ProcessDialog processDialog=new ProcessDialog(this,"短进程优先流程图",false,num,numall);
                   processDialog.setVisible(true);
                   Process mid=new Process();
                   int timeout2=0;
                   for(int times2=num-1;times2>=0;times2--)
                      {
                         for(int j=0;j<times2;j++)
                            {
                               if(process[j].length<process[j+1].length)
                                  {
                                     mid=process[j];
                                     process[j]=process[j+1];
                                     process[j+1]=mid;
                                  }
                            }
                              for(int n=0;n<process[times2].length;n++)
                                 {
                                    Graphics g1=processDialog.canvasoutput.getGraphics();
                                    processDialog.canvasoutput.firstpaint(g1);
                                    processDialog.canvasoutput.nextpaint(g1,timeout2,process[times2].num-1);
                                    timeout2=timeout2+1;
                                    text.append("\n正在执行"+process[times2].num+"号进程内容   ");
                                    if(n==(process[times2].length-1))
                                       {
                                          text.append("进程已结束，时间为"+timeout2);
                                       } 
                                 } 
                      }
                                    try
                                      {
                                          Thread.sleep(7000);
                                      }
                                    catch(InterruptedException e1){} 
                  processDialog.setVisible(false);
                }
            if(e.getSource()==rrbutton)
               {
                  ProcessDialog processDialog=new ProcessDialog(this,"时间分片流程图",false,num,numall);
                  processDialog.setVisible(true);
                  int timeout=0;
                  int times=0;
                  Process mid=new Process();
                  text.append("\n用时间分片算法运行\n\n");
                   for(int times2=1;times2<=num-1;times2++)
                      {
                         for(int j=num-2;j>=times2-1;j--)
                            {
                               if(process[j].num>process[j+1].num)
                                  {
                                     mid=process[j];
                                     process[j]=process[j+1];
                                     process[j+1]=mid;
                                  }
                            }
                       }
                  for(int j=1;j<=nummax;j++)
                     {
                        for(int n=0;n<num;n++)
                           {
                              if(j<process[n].length)
                                 {
                                    Graphics g1=processDialog.canvasoutput.getGraphics();
                                    processDialog.canvasoutput.firstpaint(g1);
                                    processDialog.canvasoutput.nextpaint(g1,times,n);
                                    times++;
                                    text.append("正在执行"+(n+1)+"号进程内容   ");
                                    timeout=timeout+1;
                                    text.append("\n");
                                       } 
                              if(j==process[n].length)
                                 {
                                    Graphics g1=processDialog.canvasoutput.getGraphics();
                                    processDialog.canvasoutput.firstpaint(g1);
                                    processDialog.canvasoutput.nextpaint(g1,times,n);
                                    times++;
                                    timeout=timeout+1;
                                    text.append("正在执行"+(n+1)+"号进程内容      程序已结束，时间为"+timeout);
                                    text.append("\n");
                                 } 

                           }
                     }
                                    try
                                        {
                                            Thread.sleep(4000);
                                        }
                                    catch(InterruptedException e1){
System.out.println("zcasfd");} 
                  processDialog.setVisible(false);
               }
         }
   }
public class Experiment1
   {
      public static void main(String args[])
         {
            new ProcessFrame("操作系统第一次实验,2506302020苏玮");
         } 
   }