欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 3769|回復: 2
打印 上一主題 下一主題
收起左側

關于時間輪轉調度的操作系統的JAVA程序設計

[復制鏈接]
跳轉到指定樓層
樓主
ID:574923 發表于 2019-6-30 10:56 | 只看該作者 回帖獎勵 |倒序瀏覽 |閱讀模式
《操作系統原理》是計算機科學與技術專業的，也是研究生入學考試中計算機專業綜合中所涉及的內容。理論性強，純粹的理論學習相對枯燥乏味，不易理解。通過設計，可加強學生對原理知識的理解。
二、設計的任務和要求

本次設計的題目是，時間片輪轉調度算法的模擬實現。要求在充分理解時間片輪轉調度算法原理的基礎上，編寫一個可視化的算法模擬程序。

具體任務如下：

1、根據需要，合理設計PCB結構，以適用于時間片輪轉調度算法；

2、設計模擬指令格式，并以文件形式存儲，程序能夠讀取文件并自動生成指令序列。

3、根據文件內容，建立模擬進程隊列，并能采用時間片輪轉調度算法對模擬進程進行調度。

任務要求：

1、進程的個數，進程的內容（即進程的功能序列）來源于一個進程序列描述文件。

2、需將調度過程輸出到一個運行日志文件。

3、開發平臺及語言不限。

4、要求設計一個Windows可視化應用程序。


3、需求分析
在計算機系統中，可能同時有數百個批處理作業存放在磁盤的作業隊列中，或者有數百個終端與主機相連接，這樣一來內存和處理器等資源便供不應求。如何從這些作業中挑選作業進入主存運行、如何在進程之間分配處理器時間，無疑是操作系統資源管理中的一個重要問題。因此引入處理器調度用來完成涉及處理器分配的工作，而其中的低級調度，執行分配CPU 的程序即分派程序(dispatcher)，它是操作系統最為核心的部分，執行十分頻繁，低級調度策略優劣直接影響到整個系統的性能。
引入的目的是按照某種原則決定就緒隊列中的哪個進程或內核級線程能獲得處理器，并將處理器出讓給它進行工作。
4、總體設計
  

5、詳細設計與實現[含代碼和實現界面]

【代碼】
  1. package one;

  3. import java.awt.BorderLayout;
  4. import java.awt.EventQueue;

  6. import javax.swing.JFrame;
  7. import javax.swing.JPanel;
  8. import javax.swing.border.EmptyBorder;
  9. import javax.swing.JLabel;
  10. import javax.swing.JButton;
  11. import javax.swing.JFileChooser;

  13. import java.awt.event.ActionListener;
  14. import java.io.BufferedReader;
  15. import java.io.BufferedWriter;
  16. import java.io.File;
  17. import java.io.FileOutputStream;
  18. import java.io.FileReader;
  19. import java.io.FileWriter;
  20. import java.io.IOException;
  21. import java.util.ArrayList;
  22. import java.util.Date;
  23. import java.util.List;
  24. import java.util.Timer;
  25. import java.util.TimerTask;
  26. import java.awt.event.ActionEvent;
  27. import javax.swing.JTextField;
  28. import javax.swing.JList;
  29. import javax.swing.JOptionPane;
  30. import javax.swing.JTextPane;
  31. import javax.swing.JTextArea;


  34. class PCB{
  35.               public String pname;//進程名稱
  36.               public List<Instruction> pInstructions;//進程中指針列表
  37.               public int CurrentInstruction;//當前運行指令索引
  38.               PCB(){
  39.                             this.pInstructions = new ArrayList<Instruction>();
  40.               }
  41. }

  43. class Instruction{
  44.               public char IName;//指令類型
  45.               public double IRemainTime;//指令運行時間
  46.               public double IRuntime;////指令剩余運行時間
  47.               Instruction(){
  48.               }            
  49. }

  51. public class Test extends JFrame {

  53.               private JPanel contentPane;
  54.               JTextField text_timeslice = new JTextField();
  55.               JTextField textRunningProcess = new JTextField();
  56.               JTextPane text_ready_queue = new JTextPane();
  57.               JTextPane text_iwait_queue = new JTextPane();
  58.               JTextPane text_other_queue = new JTextPane();
  59.               JTextPane text_owait_queue = new JTextPane();
  60.               JTextField text_count = new JTextField();
  61.               Timer time = new Timer();
  62.               int count = 0;
  63.               int num = 0;
  64.               //創建各種隊列，用ArrayList實現
  65.               List<PCB> AllQueue = new ArrayList<PCB>();
  66.               List<PCB> ReadyQueue = new ArrayList<PCB>();
  67.               List<PCB> InputWaitingQueue = new ArrayList<PCB>();
  68.               List<PCB> OutputWaitingQueue = new ArrayList<PCB>();
  69.               List<PCB> PureWaitingQueue = new ArrayList<PCB>();
  70.             
  71.             
  72.             
  73.               /**
  74.               * Launch the application.
  75.               */
  76.               public static void main(String[] args) {
  77.                             EventQueue.invokeLater(new Runnable() {
  78.                                           public void run() {
  79.                                                         try {
  80.                                                                       Test frame = new Test();
  81.                                                                       frame.setVisible(true);
  82.                                                         } catch (Exception e) {
  83.                                                                       e.printStackTrace();
  84.                                                         }
  85.                                           }
  86.                             });
  87.               }

  89.               /**
  90.               * Create the frame.
  91.               */
  92.               public Test() {
  93.                             setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  94.                             setBounds(100, 100, 956, 621);
  95.                             contentPane = new JPanel();
  96.                             contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  97.                             setContentPane(contentPane);
  98.                             contentPane.setLayout(null);
  99.                            
  100.                             JLabel label = new JLabel("\u65F6\u95F4\u7247:");
  101.                             label.setBounds(650, 53, 60, 18);
  102.                             contentPane.add(label);
  103.                            
  104.                             JButton btnOpenFile = new JButton("\u6253\u5F00\u6587\u4EF6");
  105.                             btnOpenFile.addActionListener(new ActionListener() {
  106.                                           public void actionPerformed(ActionEvent arg0) {
  107.                                                         JFileChooser chooser = new JFileChooser();
  108.                 if (chooser.showOpenDialog(btnOpenFile)==JFileChooser.APPROVE_OPTION) {//
  109.                     File file = chooser.getSelectedFile();
  110.                     textRunningProcess.setText(file.getName());
  111.                     readFile(file);
  112.                 };
  113.                                           }
  114.                             });
  115.                             btnOpenFile.setBounds(76, 49, 113, 27);
  116.                             contentPane.add(btnOpenFile);
  117.                            
  118.                             //開始調度按鈕事件
  119.                             JButton btnStartSchedule = new JButton("\u5F00\u59CB\u8C03\u5EA6");
  120.                             btnStartSchedule.addActionListener(new ActionListener() {
  121.                                           public void actionPerformed(ActionEvent e) {
  122.                                                         if(text_timeslice.getText().equals("")) {
  123.                                                                       JOptionPane.showMessageDialog(null,"請輸入時間片大小!");
  124.                                                         }
  125.                                                         else {
  126.                                                                       TimerTask task = new TimerTask() {
  127.                                                                                     public void run() {
  128.                                                                                                   RunOneTime();
  129.                                                                                                 
  130.                                                                                     }
  131.                                                                       };
  132.                                                                       btnStartSchedule.setEnabled(false);
  133.                                                                       time.schedule(task,new Date(),Long.parseLong(text_timeslice.getText()) );
  134.                                                         }
  135.                                           }
  136.                             });
  137.                             btnStartSchedule.setBounds(253, 49, 113, 27);
  138.                             contentPane.add(btnStartSchedule);
  139.                            
  140.                             //暫停調度按鈕事件
  141.                             JButton btnPauseSchedule = new JButton("\u6682\u505C\u8C03\u5EA6");
  142.                             btnPauseSchedule.addActionListener(new ActionListener() {
  143.                                           public void actionPerformed(ActionEvent e) {
  144.                                                         time.cancel();
  145.                                           }
  146.                             });
  147.                             btnPauseSchedule.setBounds(438, 49, 113, 27);
  148.                             contentPane.add(btnPauseSchedule);
  149.                            
  150.                            
  151.                             text_timeslice.setBounds(714, 50, 113, 24);
  152.                             contentPane.add(text_timeslice);
  153.                             text_timeslice.setColumns(10);
  154.                            
  155.                             JLabel label_1 = new JLabel("\u5F53\u524D\u8FD0\u884C\u8FDB\u7A0B:");
  156.                             label_1.setBounds(76, 108, 103, 18);
  157.                             contentPane.add(label_1);
  158.                            
  159.                            
  160.                             textRunningProcess.setBounds(76, 139, 103, 24);
  161.                             contentPane.add(textRunningProcess);
  162.                             textRunningProcess.setColumns(10);
  163.                            
  164.                             JLabel label_2 = new JLabel("\u5C31\u7EEA\u961F\u5217");
  165.                             label_2.setBounds(57, 205, 72, 18);
  166.                             contentPane.add(label_2);
  167.                            
  168.                             JLabel label_3 = new JLabel("\u8F93\u5165\u7B49\u5F85\u961F\u5217");
  169.                             label_3.setBounds(291, 205, 96, 18);
  170.                             contentPane.add(label_3);
  171.                            
  172.                             JLabel label_4 = new JLabel("\u8F93\u51FA\u7B49\u5F85\u961F\u5217");
  173.                             label_4.setBounds(497, 205, 96, 18);
  174.                             contentPane.add(label_4);
  175.                            
  176.                             JLabel label_5 = new JLabel("\u5176\u5B83\u7B49\u5F85\u961F\u5217");
  177.                             label_5.setBounds(721, 205, 96, 18);
  178.                             contentPane.add(label_5);
  179.                            
  180.                             text_ready_queue.setBounds(43, 236, 146, 205);
  181.                             contentPane.add(text_ready_queue);
  182.                            
  183.                            
  184.                             text_iwait_queue.setBounds(273, 236, 146, 205);
  185.                             contentPane.add(text_iwait_queue);
  186.                            
  187.                             text_owait_queue.setBounds(490, 236, 146, 205);
  188.                             contentPane.add(text_owait_queue);
  189.                            
  190.                            
  191.                             text_other_queue.setBounds(704, 236, 146, 205);
  192.                             contentPane.add(text_other_queue);
  193.                            

  195.                            
  196.                            
  197.                            
  198.               }
  199.               public void readFile(File file){//讀文件
  200.         BufferedReader bReader;
  201.         try {
  202.             bReader=new BufferedReader(new FileReader(file));
  203.             StringBuffer sBuffer=new StringBuffer();
  204.             String str;
  205.             while((str=bReader.readLine())!=null){
  206.                 sBuffer.append(str+'\n');
  207.                 switch(str.charAt(0)) {
  208.                 case 'P':
  209.                               PCB p = new PCB();
  210.                               p.pname = str;
  211.                               AllQueue.add(p);
  212.                               break;
  213.                 case 'C':
  214.                               Instruction ins1 = new Instruction();
  215.                               ins1.IRemainTime = Integer.parseInt(str.substring(1,3));
  216.                               ins1.IName = 'C';
  217.                               AllQueue.get(AllQueue.size()-1).pInstructions.add(ins1);
  218.                               break;
  219.                 case 'I':
  220.                               Instruction ins2 = new Instruction();
  221.                               ins2.IRemainTime = Integer.parseInt(str.substring(1,3));
  222.                               ins2.IName = 'I';
  223.                               AllQueue.get(AllQueue.size()-1).pInstructions.add(ins2);
  224.                               break;
  225.                 case 'O':
  226.                               Instruction ins3 = new Instruction();
  227.                               ins3.IRemainTime = Integer.parseInt(str.substring(1,3));
  228.                               ins3.IName = 'O';
  229.                               AllQueue.get(AllQueue.size()-1).pInstructions.add(ins3);
  230.                               break;
  231.                 case 'W':
  232.                               Instruction ins4 = new Instruction();
  233.                               ins4.IRemainTime = Integer.parseInt(str.substring(1,3));
  234.                               ins4.IName = 'W';
  235.                               AllQueue.get(AllQueue.size()-1).pInstructions.add(ins4);
  236.                               break;
  237.                 case 'H':
  238.                               Instruction ins5 = new Instruction();
  239.                               ins5.IRemainTime = Integer.parseInt(str.substring(1,3));
  240.                               ins5.IName = 'H';
  241.                               AllQueue.get(AllQueue.size()-1).pInstructions.add(ins5);
  242.                               break;
  243.                 }//switch                    
  244.             }//while


  247. //            String s1 = "";
  248. //            for(PCB p:ReadyQueue) {
  249. //                          s1 = s1+p.pname+"\r\n";
  250. //            }
  251. //            text_ready_queue.setText(s1);


  254.             //根據每個進程的首指令將進程分配到各個隊列中

  256. //            for(PCB p:AllQueue) {
  257. //                           switch(p.pInstructions.get(0).IName) {
  258. //                           case 'C':
  259. //                                         ReadyQueue.add(p);
  260. //                                         break;
  261. //                           case 'I':
  262. //                                         InputWaitingQueue.add(p);
  263. //                                         break;
  264. //                           case 'O':
  265. //                                         OutputWaitingQueue.add(p);
  266. //                                         break;
  267. //                           case 'W':
  268. //                                         PureWaitingQueue.add(p);
  269. //                                         break;
  270. //                           case 'H':
  271. //                                         break;
  272. //                           }
  273. //             }
  274. //           
  275.             String s1 = "";
  276.           for(PCB p:AllQueue) {
  277.                         s1 = s1+p.pname+"\r\n";
  278.           }
  279.           text_ready_queue.setText(s1);
  280.             //將界面正確顯示
  281. //            String s1 = "";
  282. //            for(PCB p:ReadyQueue) {
  283. //                          s1 = s1+p.pname+"\r\n";
  284. //            }
  285. //            text_ready_queue.setText(s1);
  286. //           
  287. //            String s2 = "";
  288. //            for(PCB p:InputWaitingQueue) {
  289. //                          s2 = s2+p.pname+"\r\n";
  290. //            }
  291. //            text_iwait_queue.setText(s2);
  292. //           
  293. //            String s3 = "";
  294. //            for(PCB p:OutputWaitingQueue) {
  295. //                          s3 = s3+p.pname+"\r\n";
  296. //            }
  297. //            text_owait_queue.setText(s3);
  298. //           
  299. //            String s4 = "";
  300. //            for(PCB p:PureWaitingQueue) {
  301. //                          s4 = s4+p.pname+"\r\n";
  302. //            }
  303. //            text_other_queue.setText(s4);

  305.         } catch (Exception e) {
  306.             // TODO: handle exception
  307.         }
  308.     }
  309.             
  310.             
  311.               //每隔一個時間間隔運行一次
  312.               public void RunOneTime() {
  313.                             int size = AllQueue.size();
  314.                             if(num<size) {
  315.                                           PCB p = AllQueue.get(num);
  316.                                           switch(p.pInstructions.get(0).IName) {
  317.                                  case 'C':
  318.                                                ReadyQueue.add(p);
  319.                                                break;
  320.                                  case 'I':
  321.                                                InputWaitingQueue.add(p);
  322.                                                break;
  323.                                  case 'O':
  324.                                                OutputWaitingQueue.add(p);
  325.                                                break;
  326.                                  case 'W':
  327.                                                PureWaitingQueue.add(p);
  328.                                                break;
  329.                                  case 'H':
  330.                                                break;
  331.                                  }
  332.                                           num++;
  333.                             }
  334.                            
  335.                             //只要有隊列不為空就一直調度
  336.                             if(ReadyQueue.size()!=0||InputWaitingQueue.size()!=0||OutputWaitingQueue.size()!=0||PureWaitingQueue.size()!=0) {
  337.                                          
  338.                                           //只有一個CPU，所以只能對就緒隊列的第一個PCB的運行指令時間進行減一操作
  339.                                           if(ReadyQueue.size()!=0) {
  340.                                                         if(ReadyQueue.get(0).pInstructions.get(ReadyQueue.get(0).CurrentInstruction).IRemainTime==0) {
  341.                                                                       ReadyQueue.get(0).CurrentInstruction++;
  342.                                                                       switch(ReadyQueue.get(0).pInstructions.get(ReadyQueue.get(0).CurrentInstruction).IName) {
  343.                                                                       case 'C':
  344.                                                                                     ReadyQueue.add(ReadyQueue.get(0));//先加再刪，ArrayList的好處，動態添加和刪除，[1,2,3]把1刪了再加，就是[2,,3,1]了
  345.                                                                                     ReadyQueue.remove(ReadyQueue.get(0));
  346.                                                                                     break;
  347.                                                                       case 'I':
  348.                                                                                     InputWaitingQueue.add(ReadyQueue.get(0));
  349.                                                                                     ReadyQueue.remove(ReadyQueue.get(0));
  350.                                                                                     break;
  351.                                                                       case 'O':
  352.                                                                                     OutputWaitingQueue.add(ReadyQueue.get(0));
  353.                                                                                     ReadyQueue.remove(ReadyQueue.get(0));
  354.                                                                                     break;
  355.                                                                       case 'W':
  356.                                                                                     PureWaitingQueue.add(ReadyQueue.get(0));
  357.                                                                                     ReadyQueue.remove(ReadyQueue.get(0));
  358.                                                                                     break;
  359.                                                                       case 'H':
  360.                                                                                     ReadyQueue.remove(ReadyQueue.get(0));
  361.                                                                                     break;
  362.                                                                       }
  363.                                                         }
  364.                                                         else {
  365.                                                                       ReadyQueue.get(0).pInstructions.get(ReadyQueue.get(0).CurrentInstruction).IRemainTime--;
  366.                                                                       textRunningProcess.setText(ReadyQueue.get(0).pname);
  367.                                                                       ReadyQueue.add(ReadyQueue.get(0));
  368.                                                                       ReadyQueue.remove(ReadyQueue.get(0));
  369.                                                         }
  370.                                           }
  371.                                          
  372.                                           //輸入等待隊列和輸出等待隊列以及其它等待隊列之所以采用for循環是因為任務書上說I/O設備不限，所以可以對這幾個隊列的每個PCB進行減一
  373.                                           if(InputWaitingQueue.size()!=0) {
  374.                                                         for(int i=0;i<=InputWaitingQueue.size()-1;i++) {
  375.                                                                       if(InputWaitingQueue.get(i).pInstructions.get(InputWaitingQueue.get(i).CurrentInstruction).IRemainTime==0) {
  376.                                                                                     InputWaitingQueue.get(i).CurrentInstruction++;
  377.                                                                                     switch(InputWaitingQueue.get(i).pInstructions.get(InputWaitingQueue.get(i).CurrentInstruction).IName) {
  378.                                                                                     case 'C':
  379.                                                                                                   ReadyQueue.add(InputWaitingQueue.get(i));
  380.                                                                                                   InputWaitingQueue.remove(InputWaitingQueue.get(i));
  381.                                                                                                   break;
  382.                                                                                     case 'I':
  383.                                                                                                   InputWaitingQueue.add(InputWaitingQueue.get(i));
  384.                                                                                                   InputWaitingQueue.remove(InputWaitingQueue.get(i));
  385.                                                                                                   break;
  386.                                                                                     case 'O':
  387.                                                                                                   OutputWaitingQueue.add(InputWaitingQueue.get(i));
  388.                                                                                                   InputWaitingQueue.remove(InputWaitingQueue.get(i));
  389.                                                                                                   break;
  390.                                                                                     case 'W':
  391.                                                                                                   PureWaitingQueue.add(InputWaitingQueue.get(i));
  392.                                                                                                   InputWaitingQueue.remove(InputWaitingQueue.get(i));
  393.                                                                                                   break;
  394.                                                                                     case 'H':
  395.                                                                                                   InputWaitingQueue.remove(InputWaitingQueue.get(i));
  396.                                                                                                   break;
  397.                                                                                     }
  398.                                                                       }
  399.                                                                       else {
  400.                                                                                     InputWaitingQueue.get(i).pInstructions.get(InputWaitingQueue.get(i).CurrentInstruction).IRemainTime--;
  401.                                                                       }
  402.                                                         }
  403.                                           }
  404.                                          
  405.                                           if(OutputWaitingQueue.size()!=0) {
  406.                                                         for(int i=0;i<=OutputWaitingQueue.size()-1;i++) {
  407.                                                                       if(OutputWaitingQueue.get(i).pInstructions.get(OutputWaitingQueue.get(i).CurrentInstruction).IRemainTime==0) {
  408.                                                                                     OutputWaitingQueue.get(i).CurrentInstruction++;
  409.                                                                                     switch(OutputWaitingQueue.get(i).pInstructions.get(OutputWaitingQueue.get(i).CurrentInstruction).IName) {
  410.                                                                                     case 'C':
  411.                                                                                                   ReadyQueue.add(OutputWaitingQueue.get(i));
  412.                                                                                                   OutputWaitingQueue.remove(OutputWaitingQueue.get(i));
  413.                                                                                                   break;
  414.                                                                                     case 'I':
  415.                                                                                                   InputWaitingQueue.add(OutputWaitingQueue.get(i));
  416.                                                                                                   OutputWaitingQueue.remove(OutputWaitingQueue.get(i));
  417.                                                                                                   break;
  418.                                                                                     case 'O':
  419.                                                                                                   OutputWaitingQueue.add(OutputWaitingQueue.get(i));
  420.                                                                                                   OutputWaitingQueue.remove(OutputWaitingQueue.get(i));
  421.                                                                                                   break;
  422.                                                                                     case 'W':
  423.                                                                                                   PureWaitingQueue.add(OutputWaitingQueue.get(i));
  424.                                                                                                   OutputWaitingQueue.remove(OutputWaitingQueue.get(i));
  425.                                                                                                   break;
  426.                                                                                     case 'H':
  427.                                                                                                   OutputWaitingQueue.remove(OutputWaitingQueue.get(i));
  428.                                                                                                   break;
  429.                                                                                     }
  430.                                                                       }
  431.                                                                       else {
  432.                                                                                     OutputWaitingQueue.get(i).pInstructions.get(OutputWaitingQueue.get(i).CurrentInstruction).IRemainTime--;
  433.                                                                       }
  434.                                                         }
  435.                                           }
  436.                                          
  437.                                           if(PureWaitingQueue.size()!=0) {
  438.                                                         for(int i=0;i<=PureWaitingQueue.size()-1;i++) {
  439.                                                                       if(PureWaitingQueue.get(i).pInstructions.get(PureWaitingQueue.get(i).CurrentInstruction).IRemainTime==0) {
  440.                                                                                     PureWaitingQueue.get(i).CurrentInstruction++;
  441.                                                                                     switch(PureWaitingQueue.get(i).pInstructions.get(PureWaitingQueue.get(i).CurrentInstruction).IName) {
  442.                                                                                     case 'C':
  443.                                                                                                   ReadyQueue.add(PureWaitingQueue.get(i));
  444.                                                                                                   PureWaitingQueue.remove(PureWaitingQueue.get(i));
  445.                                                                                                   break;
  446.                                                                                     case 'I':
  447.                                                                                                   InputWaitingQueue.add(PureWaitingQueue.get(i));
  448.                                                                                                   PureWaitingQueue.remove(PureWaitingQueue.get(i));
  449.                                                                                                   break;
  450.                                                                                     case 'O':
  451.                                                                                                   OutputWaitingQueue.add(PureWaitingQueue.get(i));
  452.                                                                                                   PureWaitingQueue.remove(PureWaitingQueue.get(i));
  453.                                                                                                   break;
  454.                                                                                     case 'W':
  455.                                                                                                   PureWaitingQueue.add(PureWaitingQueue.get(i));
  456.                                                                                                   PureWaitingQueue.remove(PureWaitingQueue.get(i));
  457.                                                                                                   break;
  458.                                                                                     case 'H':
  459.                                                                                                   PureWaitingQueue.remove(PureWaitingQueue.get(i));
  460.                                                                                                   break;
  461.                                                                                     }
  462.                                                                       }
  463.                                                                       else {
  464.                                                                                     PureWaitingQueue.get(i).pInstructions.get(PureWaitingQueue.get(i).CurrentInstruction).IRemainTime--;
  465.                                                                       }
  466.                                                         }
  467.                                           }
  468.                                          
  469.                                           //所有用到CPU資源的PCB都沒了就清空這個控件
  470.                                           if(ReadyQueue.size()==0) {
  471.                                                         textRunningProcess.setText("");
  472.                                           }
  473.                                          
  474.                                           //每進行一次調度就更新一次控件的信息
  475.                                           String str1 = "";
  476.                                           for(int i=0;i<ReadyQueue.size();i++) {
  477.                                                         str1 = str1+ReadyQueue.get(i).pname+"\r\n";
  478.                                           }
  479.                                           text_ready_queue.setText(str1);
  480.                                          
  481.                                           String str2 = "";
  482.                                           for(int i=0;i<InputWaitingQueue.size();i++) {
  483.                                                         str2 = str2+InputWaitingQueue.get(i).pname+"\r\n";
  484.                                           }
  485.                                           text_iwait_queue.setText(str2);
  486.                                          
  487.                                           String str3 = "";
  488.                                           for(int i=0;i<OutputWaitingQueue.size();i++) {
  489.                                                         str3 = str3+OutputWaitingQueue.get(i).pname+"\r\n";
  490.                                           }
  491.                                           text_owait_queue.setText(str3);
  492.                                          
  493.                                           String str4 = "";
  494.                                           for(int i=0;i<PureWaitingQueue.size();i++) {
  495.                                                         str4 = str4+PureWaitingQueue.get(i).pname+"\r\n";
  496.                                           }
  497.                                           text_other_queue.setText(str4);
  498.                                          
  499.                                           count++;
  500.                                          
  501.                                           String schedule = "第"+String.valueOf(count)+"次調度情況:\r\n"+"就緒隊列:\r\n"+str1+"\r\n"+"輸入等待隊列:\r\n"+str2+"\r\n"
  502.                                                                                                                                             +"輸出等待隊列:\r\n"+str3+"\r\n"+"其它等待隊列:\r\n"+str4+"\r\n";
  503.                                           writeFile(schedule);
  504.                             }
  505.                             else {
  506.                                           JOptionPane.showMessageDialog(null, "調度結束！");
  507.                                           time.cancel();
  508.                             }
  509.               }
  510.               public static void writeFile(String text) {
  511.         try {
  512.             File writeName = new File("F:\\Java201903\\output.txt"); // 相對路徑，如果沒有則要建立一個新的output.txt文件
  513. //            writeName.createNewFile(); // 創建新文件,有同名的文件的話直接覆蓋
  514.             try (FileWriter writer = new FileWriter(writeName,true);//追加
  515.                  BufferedWriter out = new BufferedWriter(writer)
  516.             ) {
  517.                 out.write(text);
  518.                 out.flush(); // 把緩存區內容壓入文件
  519.             }
  520.         } catch (IOException e) {
  521.             e.printStackTrace();
  522.         }
  523.     }

  525. }
復制代碼

這次課設我提前有嘗試自己來實現，查了一些網上的思路，書本上的算法，然后就試著慢慢寫，遇到不懂的問了同學和老師。收獲很多，在隊列中用add和remove兩個函數來實現。JAVA的好處是很多算法都直接調用就行了，對我很友好。代碼不是很簡潔，應該試著再改一下的。我覺得我應該花更多的時間在代碼的學習和運用上。

以上內容Word格式文檔51黑下載地址：
操作系統課程設計報告.doc (335 KB, 下載次數: 25)


評分

參與人數 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏1 分享淘帖 頂頂1 踩踩
回復

使用道具 舉報

無效樓層，該帖已經被刪除
板凳
ID:934927 發表于 2021-6-9 18:37 | 只看該作者
The public type Test must be defined in its own file 樓主您好 我直接復制您的代碼報錯了 請問源文件還在嗎
回復

使用道具 舉報

地板
ID:1058238 發表于 2022-12-19 09:58 | 只看該作者
wizardbcat 發表于 2021-6-9 18:37
The public type Test must be defined in its own file 樓主您好 我直接復制您的代碼報錯了 請問源文件還 ...

把你的包名改成one就好了
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表