processor.java~150~

操作系统课程设计

    	Object obj=e.getSource();
    	if(obj == jRadioButton1) {
    		arithmetic = "FCFS_RR";
    	}
    	else if(obj == jRadioButton2){
    		arithmetic = "SPF";
    	}

    }

    public void run() {
    	while (true) {
    		try {
                if(arithmetic.equals("FCFS_RR")) {//先来先服务，按时间片处理
                	for (int i = 0; i < PCBList_ready.size(); i++) {
                        PCB pcb = (PCB) PCBList_ready.get(i); //获取就绪队列的第i个元素
                        //pcb.SetRuntime_already(timeslice);
                        pcb.SetState("Running"); //将当前进程的状态改为运行状态

                        //显示进程的相关信息
                        this.SetTable_FCFS();
                        for (int j = 0; j < PCBList_ready.size(); j++) {//把就绪进程的相关信息添加到表格中
                            PCB pcb1 = (PCB) PCBList_ready.get(j);//获取第j个元素
                            data = new Vector();
                            data.addElement(pcb1.GetID());
                            data.addElement(pcb1.GetState());
                            data.addElement(Integer.toString(pcb1.
                                    GetRuntime_total()));
                            data.addElement(Integer.toString(pcb1.
                                    GetRuntime_already()));
                            tableModel.addRow(data);
                        }
                        for (int j = 0; j < PCBList_wait.size(); j++) {//把等待进程的相关信息添加到表格中
                            PCB pcb1 = (PCB) PCBList_wait.get(j);
                            pcb1.SetState("Waitting");
                            data = new Vector();
                            data.addElement(pcb1.GetID());
                            data.addElement(pcb1.GetState());
                            data.addElement(Integer.toString(pcb1.
                                    GetRuntime_total()));
                            data.addElement(Integer.toString(pcb1.
                                    GetRuntime_already()));
                            tableModel.addRow(data);
                        }
                        jLabel1.setText("处理机忙，进程" + pcb.GetID() + "占用处理机。");//显示处理机的状态
                        jLabel1.setForeground(Color.RED);//设置字体颜色

                        int sparetime = pcb.GetRuntime_total() -
                                        pcb.GetRuntime_already(); //计算当前进程还需运行的时间

                        if (sparetime < timeslice) { //当前进程所需的运行时间比时间片小，对进程占用处理机的之间进行变换，使得处理机能够及时被释放
                            Thread.sleep(pauseTime * sparetime);
                        }
                        else { //当前进程占用处理机的时间为一个时间片
                            Thread.sleep(pauseTime * timeslice);
                        }

                        if (sparetime > timeslice) { //当前进程的时间片到了，且该进程尚未结束，修改该进程的已运行时间和运行状态
                            pcb.SetRuntime_already(pcb.GetRuntime_already() +
                                    timeslice);//把进程的已运行时间增加一个时间片的时间
                            pcb.SetState("Ready"); //把进程的状态修改为就绪状态
                        }
                        else
                        { //进程处理完毕
                            PCBList_ready.remove(i); //把处理完的进程的PCB移出就绪队列
                            i--;//移除进程后面的就绪进程向前移动一个单位，对循环变量进行减一
                            int r[] = pcb.GetMemoryID();//获取处理完的进程的PCB的内存标识
                            m.cleanMemory(r[0]);//回收处理完的进程所占的内存空间
                            for(int j = 0;j < PCBList_wait.size();j++) {//尝试把等待队列中的进程调入就绪队列
                                PCB pcb_w = (PCB) PCBList_wait.getFirst();//获取等待队列的第一个进程
                                int r_w[] = pcb_w.GetMemoryID();//获取该进程的内存标识
                                int waitID = m.waitTOrunnable(r_w[0]);//判断能否调入就绪队列，返回能否调入就绪队列的标识，-1表示调入
                                if(waitID != -1) {//判断是否调入，调入后则进行相应的处理
                                    PCBList_wait.remove();//移除等待队列的第一个进程，即调入就绪队列的进程
                                    r_w[0] = waitID;
                                    r_w[1] = 1;
                                    pcb_w.SetMemoryID(r_w);//设置该进程的内存标识
                                    pcb_w.SetState("Ready"); //把进程的状态修改为就绪状态
                                    PCBList_ready.add(pcb_w);//把进程添加到就绪队列的队尾
                                    j--;
                                }

                            }
                        }
                        if (PCBList_ready.size() == 0) { //判断就绪队列是否为空，如果为空则 break
                            jLabel1.setText("处理机空闲");
                            //jLabel1.setBackground(Color.RED);//设置标签颜色
                            jLabel1.setForeground(Color.GREEN);//设置字体颜色
                            this.SetTable_FCFS();
                            break;
                            //return;
                        }
                    }
                }
                else if(arithmetic.equals("SPF")) {//短进程优先
                	for(int i = 0;i< PCBList_ready.size();i++) {
                		for(int j = 0;j<PCBList_ready.size() - 1;j++) {//对就绪进程进行排序
                            for(int k = j + 1;k < PCBList_ready.size();k++) {
                                int a = ((PCB) PCBList_ready.get(j)).GetRuntime_total() - ((PCB) PCBList_ready.get(j)).GetRuntime_already();
                                int b = ((PCB) PCBList_ready.get(k)).GetRuntime_total() - ((PCB) PCBList_ready.get(k)).GetRuntime_already();
                                if(a > b) {
                                    PCB pcb1 = (PCB) PCBList_ready.get(j);
                                    PCB pcb2 = (PCB) PCBList_ready.get(k);
                                    PCBList_ready.remove(j);
                                    PCBList_ready.add(j,pcb2);
                                    PCBList_ready.remove(k);
                                    PCBList_ready.add(k,pcb1);
                                }
                            }
                        }
                        PCB pcb = (PCB) PCBList_ready.get(i); //获取就绪队列的第i个元素
                        //pcb.SetRuntime_already(timeslice);
                        pcb.SetState("Running"); //将当前进程的状态改为运行状态
                        this.SetTable_SPF();
                        for (int j = 0; j < PCBList_ready.size(); j++) {//将就绪进程显示到表格中
                            PCB pcb1 = (PCB) PCBList_ready.get(j);
                            data = new Vector();
                            data.addElement(pcb1.GetID());
                            data.addElement(pcb1.GetState());
                            data.addElement(Integer.toString(pcb1.GetRuntime_total()));
                            //data.addElement(Integer.toString(pcb1.GetRuntime_already()));
                            tableModel.addRow(data);
                        }
                        for (int j = 0; j < PCBList_wait.size(); j++) {//将等待进程显示到表格中
                            PCB pcb1 = (PCB) PCBList_wait.get(j);
                            pcb1.SetState("Waitting");//将当前进程的状态改为等待状态
                            data = new Vector();
                            data.addElement(pcb1.GetID());
                            data.addElement(pcb1.GetState());
                            data.addElement(Integer.toString(pcb1.GetRuntime_total()));
                            //data.addElement(Integer.toString(pcb1.GetRuntime_already()));
                            tableModel.addRow(data);
                        }

                        jLabel1.setText("处理机忙，进程" + pcb.GetID() + "占用处理机。");
                        jLabel1.setForeground(Color.RED);//设置字体颜色
                        Thread.sleep((pcb.GetRuntime_total() - pcb.GetRuntime_already()) * pauseTime);
                        PCBList_ready.remove(i);
                        i--;
                        int memoryID[] = pcb.GetMemoryID();
                        m.cleanMemory(memoryID[0]);
                        for(int j = 0;j < PCBList_wait.size();j++) {
                            PCB pcb_w = (PCB) PCBList_wait.getFirst();
                            int r_w[] = pcb_w.GetMemoryID();
                            int waitID = m.waitTOrunnable(r_w[0]);
                            if(waitID != -1) {
                                PCBList_wait.remove();
                                r_w[0] = waitID;
                                r_w[1] = 1;
                                pcb_w.SetMemoryID(r_w);
                                pcb_w.SetState("Ready"); //把进程的状态修改为就绪状态
                                PCBList_ready.add(pcb_w);
                                j--;
                            }
                        }
                        if (PCBList_ready.size() == 0) { //判断就绪队列是否为空，如果为空则 break
                            jLabel1.setText("处理机空闲");
                            //jLabel1.setBackground(Color.RED);//设置标签颜色
                            jLabel1.setForeground(Color.GREEN);//设置字体颜色
                            this.SetTable_SPF();
                            break;
                            //return;
                        }
                	}
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
    	}
    }
}