memory.java

操作系统课程设计

//AP0506213 揭英虎

import javax.swing.JPanel;
import java.awt.SystemColor;
import javax.swing.JLabel;
import javax.swing.*;
import java.awt.Color;
import java.io.*;
import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.BorderFactory;
import java.awt.GridLayout;
import java.awt.FlowLayout;
import javax.swing.border.TitledBorder;

public class Memory extends JPanel
{
    JLabel store = new JLabel("存储器",JLabel.CENTER);
    JLabel memory[] = new JLabel[128];
    int memoryType[] = new int[128];
    JLabel queue = new JLabel("缓冲队列",JLabel.CENTER);
    JLabel buffer[] = new JLabel[128];
    int bufferType[] = new int[128];

    //String content[]=new String[256];    //读入内存的作业内容
    int run[][] = new int[64][3];  //就绪队列，,第1列为作业在内存的起始位置，第2列为作业的末尾位置,第3列为作业代码起始位置
    int wait[][] = new int[64][3]; //等待队列，第1列为作业在内存的起始位置，第2列为作业末尾位置,第3列为作业代码起始位置
    int codeindex = 0;  //作业内容指针
    int memorycount=128; //当前主内剩余容量
    int buffercount=128; //当前缓冲剩余容量
    double value1=0.0,value2=0.0;
    BorderLayout borderLayout1 = new BorderLayout();
    JPanel jPanel1 = new JPanel();
    JPanel jPanel2 = new JPanel();
    JPanel jPanel3 = new JPanel();
    BorderLayout borderLayout2 = new BorderLayout();
    JPanel jPanel4 = new JPanel();
    BorderLayout borderLayout3 = new BorderLayout();
    JPanel jPanel5 = new JPanel();
    JPanel jPanel6 = new JPanel();
    GridLayout gridLayout1 = new GridLayout(8,16);
    GridLayout gridLayout2 = new GridLayout(8,16);
    JProgressBar jProgressBar1 = new JProgressBar(0,100);
    JProgressBar jProgressBar2 = new JProgressBar(0,100);
    FlowLayout flowLayout1 = new FlowLayout();
    FlowLayout flowLayout2 = new FlowLayout();
    TitledBorder titledBorder1 = new TitledBorder("");


    public Memory()
    {
        //this.setSize(190,300);
        try
        {
            jbInit();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        for(int i=0;i<128;i++){
            memory[i] = new JLabel("");
            memory[i].setOpaque(true);
            memory[i].setBackground(Color.green);
            memory[i].setSize(10,10);
            jPanel4.add(memory[i]);
            memoryType[i] = 0;
        }
       for(int i=0;i<128;i++){
            buffer[i]=new JLabel("");
            buffer[i].setOpaque(true);
            buffer[i].setBackground(Color.green);
            buffer[i].setSize(10,10);
            jPanel6.add(buffer[i]);
            bufferType[i] = 0;

        }
        for(int i=0; i<run.length; i++){  //初始化就绪队列数据结构
            run[i][0] = -1;  //初始化时，队列没有任何内容，将其值置为-1
            run[i][1] = -1;
            run[i][2] = -1;
        }
        for(int i=0; i<wait.length; i++){  //初始化等待队列数据结构
            wait[i][0] = -1;
            wait[i][1] = -1;
            wait[i][2] = -1;
        }
        this.validate();
        this.setVisible(true);

    }

    //*****************************************************************************
        int[] load_job(String paths)
        {
            if(memorycount > 0 ||buffercount >0){  //若主内存或等待内存有剩余，则尝试分配
                File profile = new File(paths);
                int size = (int)profile.length();
                int fileline = 0;   //该作业的行数
                String temp = "";
                int own = 0,waitown = 0;   //在内存中开辟一块空间给作业
                int runfirst = 0,runlast = 0;  //分配给作业的主内存的起始和结束指针
                int waitfirst = 0,waitlast = 0;  //分配给作业的等待内存的起始和结束指针

                if (!profile.getName().matches("[a-zA-Z0-9]+\\.job")) {  //匹配文件名，是否为作业文件
                    JOptionPane.showMessageDialog(null, "你选择的不是作业文件", "注意",JOptionPane.WARNING_MESSAGE);
                    int r[] ={-1,-1};
                    return r;
                }
                else {
                    try {
                        BufferedReader source = new BufferedReader(new FileReader(profile)); //读入作业文件
                        while ((temp = source.readLine())!=null) { //读入1行
                            //System.out.println(temp);
                            //content[codeindex+fileline] = temp;
                            fileline++;  //读入一行，行数增加
                        }
                        source.close();
                    }
                    catch (Exception e) {
                        System.out.println("读作业操作出错");
                        e.printStackTrace();
                        int r[] ={-1,-1};
                        return r;
                    }
                    //int prolength = fileline*2; //作业长度，一行作业占2个单位内存
                    int prolength;
                    if(size%8!=0)
                        prolength = size/8+1;
                    else
                        prolength = size/8;   //作业长度，每8个字节占一个内存单元
                    if(prolength <= memorycount || prolength <= buffercount)
                    {  //如果当前空内存大于等于作业所需内存则首次适应分配
                        for(int i=0; i<128; i++)
                        {  //顺序搜索连续内存块，看是否能容纳该作业
                            if(memoryType[i] == 0){ //找到未分配的内存，连续内存块长度增加
                                own++;
                            }
                            else{   //一旦到了已被分配的内存，连续块长度置0
                                own = 0;
                                runfirst = i+1;  //内存指针移到下个内存单元
                            }
                            if(own == prolength)
                            {  //当内存连续块长度等于作业长度时，则可分配内存给该作业
                                runlast = i;
                                int memoryID = -1;
                                for(int k=0; k<run.length; k++)
                                {  //查找未记录数据的队列数据结构
                                    if(run[k][0] == -1)
                                    {
                                        memoryID = k; //用数组标记第n个作业
                                        break;
                                    }
                                }
                                run[memoryID][0] = runfirst;
                                run[memoryID][1] = runlast;
                                run[memoryID][2] = codeindex;
                                codeindex = codeindex+fileline;   //代码指针后移
                                for(int j=runfirst; j<=runlast; j++){
                                    memory[j].setBackground(Color.blue);
                                    memoryType[j] = 1;  //1表示该单位已被分配
                                    //num1=0;
                                }
                                memorycount = memorycount - (run[memoryID][1]-run[memoryID][0]+1);
                                value1=(128-memorycount)*100/128;
                                jProgressBar1.setValue((int)value1);
                                jProgressBar1.setString(String.valueOf(value1)+"%");
                                int r[] ={memoryID,1}; //1表示进入就绪队列
                                return r;
                            }
                        }