请求分页存储管理系统模拟实现（java多线程编程+GUI图形化界面设计的小实例）
项目并不完美，借鉴需考量
（ 满满干货）简单由实例讲解多线程和GUI
文末附有源码（下载链接）
1、项目介绍：
操作系统课设项目，题目是设计一个能够实现多种页面置换算法同时执行且能够暂停以及终止算法置换展示（动态展示），要想要实现同时执行，就需要程序多线程并发执行，Java对多线程编程有很好的帮助，所以我用Java。
2、程序界面截图
还有一张结果清单，就是将点击保存的结果序列（以 第i组 逻辑序列 物理序列 的形式三行一组的显示），但是我忘记截图了，那就不截了。
3、项目难点以及知识点（枚举的。。。。）
GUI方面
1、JFrame类，一些控件的使用，几大布局来控制界面。
2、内部监听器类，用来判断点击事件并执行相应的代码（继承ActionListener类）。
3、Java作为面向对象语言，可以把布局代码写在构造函数中，然后主函数中实例化，这样就可以让代码更规整，且一旦打开java程序就立刻产生界面。
4、一定要注意，一个java程序还未执行，当前界面不能对它里面的任何东西进行操作（之前我想要将第二张图中的序列放到第三张的显示区中，但是总是报错空指针，后来我改思路，让下一页从上页获取，而不是上一页设置下一页的文本框的值）。
5、设置按钮的逻辑关系（初始化、开始、暂停、继续、保存）。
多线程部分
1、线程的编写（两种方法，我用了其中之一）：继承Runnable接口，重写run()函数，这个run函数里面写线程的工作代码。
2、线程的调用：实例化线程类，创建对应的线程对象，然后 tt1.start()来启动线程。
3、线程的暂停、继续，通过改变boolean型变量的值以及wait()和notify()
来实现（每个线程类中设置控制资源时需要变量名以及内容都不同，别问为什么，我也不知道，自己试出来的，可以查百度）还有java把线程的很多容易发生事故的操作都废除了，只有用这种方法。
4、线程的终止，用变量控制，我这里直接通过改变bool变量的值来台跳出循环体，使程序提前结束。
5、其他类怎么控制上两条提到的线程中的变量，用私有成员，并添加get和set方法（请思考web项目中的po实体类怎么写的）。
4、源代码
GUI
第一张图
package reqPage;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.xml.bind.Marshaller.Listener;
/**
* 功能：学生成绩管理系统
* 步骤1、登录界面的静态实现
* author：ywq
*/
import java.awt.*;
import javax.swing.*;
public class prinMain extends JFrame{
//定义组件
JPanel jp1,jp2,jp3,jp4,jp5,jp6;//面板
JLabel jlb1;//标签
JLabel jlb2;
JLabel jlb3;
JLabel jlb4;
JLabel jlb5;
JButton jb1,jb2;//按钮
static JTextField jtf1;//逻辑页数
static JTextField jtf2;//物理页数
static JTextField jtf3;//快表时间
static JTextField jtf4;//慢表时间
static JTextField jtf5;//缺页中断处理时间
public static void main(String[] args) {
prinMain win=new prinMain();
}
//设置只能输入数字
public void myset(JTextField jtf1) {
jtf1.addKeyListener(new KeyAdapter() {
@Override
public void keyTyped(KeyEvent e) {
int temp = e.getKeyChar();
if(temp == 10){
}//按回车时
if(temp==46)
{
e.consume();
}
else{
//没有按小数点时
if(temp != 8){
//没有按backspace时
//下面检查是不是在0~9之间；
if(temp > 57){
e.consume(); //如果不是则消除key事件,也就是按了键盘以后没有反应;
}else if(temp < 48){
e.consume();
}
}
}
}
});//！！！！！！！！！！！
}
//构造函数
public prinMain(){
//创建面板
super("请求分页管理系统");
jp1=new JPanel();
jp2=new JPanel();
jp3=new JPanel();
jp4=new JPanel();
jp5=new JPanel();
jp6=new JPanel();
//创建标签
jlb1=new JLabel(" 输入页面个数");
jlb2=new JLabel(" 输入页框个数");
jlb3=new JLabel("访问快表时间(ns)");
jlb4=new JLabel("访问页表时间(ns)");
jlb5=new JLabel("中断处理时间(ns)");
//创建按钮
jb1=new JButton("恢复默认");
jb2=new JButton("下一步");
//创建文本框
jtf1=new JTextField("8",10);
jtf2=new JTextField("3",10);
jtf3=new JTextField("10",10);
jtf4=new JTextField("100",10);
jtf5=new JTextField("1000",10);
//设置只能输入数字
myset(jtf1);
myset(jtf2);
myset(jtf3);
myset(jtf4);
myset(jtf5);
//在构造函数中实例化监听器，然后向按钮添加这个监听器
myaction act=new myaction();
jb1.addActionListener(act);
jb2.addActionListener(act);
//设置布局管理
this.setLayout(new GridLayout(6, 1));//网格式布局
//加入各个组件
jp1.add(jlb1);
jp1.add(jtf1);
jp2.add(jlb2);
jp2.add(jtf2);
jp3.add(jlb3);
jp3.add(jtf3);
jp4.add(jlb4);
jp4.add(jtf4);
jp5.add(jlb5);
jp5.add(jtf5);
jp6.add(jb1);
jp6.add(jb2);
//加入到JFrame
this.add(jp1);
this.add(jp2);
this.add(jp3);
this.add(jp4);
this.add(jp5);
this.add(jp6);
//设置窗体
this.setSize(500, 350);//窗体大小
this.setLocationRelativeTo(null);//在屏幕中间显示(居中显示)
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//退出关闭JFrame
this.setVisible(true);//显示窗体
//锁定窗体
this.setResizable(false);
}
//建完监听器内部类之后，要实例化它才能用，在构造函数中实例化，等主类实例化调用构造函数时执行
class myaction implements ActionListener{
//继承监听器接口，然后改写下面这个方法，来实现点击事件行为
String str1;
int s1;
String str2;
int s2;
public void actionPerformed(ActionEvent e){
if((JButton)e.getSource()==jb2) {
str1=jtf1.getText().toString();
s1=Integer.parseInt(str1);
str2=jtf2.getText().toString();
s2=Integer.parseInt(str2);
if(s2>7||s1<s2||s1>20) {
JOptionPane.showMessageDialog(null,"页框数建议不能大于8且不能超过页面数！,页面数不能超过20个！！", "请重新输入" , JOptionPane.WARNING_MESSAGE);
}
else
{
setVisible(false); //不用加this
//dispose();//本窗口销毁,释放内存资源
new prinNext();//打开新的窗体
}
}
else if((JButton)e.getSource()==jb1) {
jtf1.setText("8");
jtf2.setText("3");
jtf3.setText("10");
jtf4.setText("100");
jtf5.setText("1000");
}
}
}
}
第二张图
package reqPage;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class prinNext extends JFrame {
JPanel jp1,jp2,jp3;
JButton jbBack,jbRandom,jbPrint;
static JButton jbAll;
static JTextField jtFou;
JLabel jl1;
//(实例化不能放在构造函数里，每次new都会调用一次构造函数！！！！)
static String[][] ru=new String[10][3];//用来存结果
static int prinNum=0;//用来存数组ru中的数量
public prinNext() {
super("请求分页管理系统");
jp1=new JPanel();
jp2=new JPanel();
jp3=new JPanel();
jbBack=new JButton("上一步");
jbRandom=new JButton("获取随机访问序列");
jbAll=new JButton("下一步");
jtFou=new JTextField(40);
jbPrint=new JButton("程序结果清单");
jl1=new JLabel("输入访问序列");
jp1.add(jl1);
jp1.add(jtFou);
jp1.add(jbRandom);
jp3.add(jbPrint);
jp2.add(jbBack);
jp2.add(jbAll);
myaction act=new myaction();
jbBack.addActionListener(act);
jbRandom.addActionListener(act);
jbAll.addActionListener(act);
jbPrint.addActionListener(act);
this.setSize(800,200);
this.setLayout(new GridLayout(3,1));//*****
this.add(jp1);
this.add(jp3);
this.add(jp2);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);//在屏幕中间显示(居中显示)
this.setVisible(true);
this.setResizable(false);//锁定窗口
String p=prinMain.jtf1.getText().toString();
int p1=Integer.parseInt(p);
System.out.printf("text:"+p1);
}
class myaction implements ActionListener {
//封装点击方法
public void clock(int p1) {
int count=0;int flag3=1;
String []list=new String [100];
//获取文本框中的文本
String tf_str = jtFou.getText().trim();
String[] t=tf_str.split(",");
String[]check=new String[] {
"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f",","};
int flag2=0;
//将文本交给文本框
//ta.setText(tf_str);
//追加文本
for (int i = 0; i <t.length; i++) {
System.out.println(t[i].length());
if(t[i].length()!=5) {
JOptionPane.showMessageDialog(null,"输入五位地址位以 ，结束", "请重新输入" , JOptionPane.WARNING_MESSAGE);flag3=0;
i--;break;
// tf.setText("");
}
for(int j=0;j<5;j++) {
String a=t[i].substring(j,j+1);
list[count]=a;
count++;
}
}
if(t.length!=p1) {
JOptionPane.showMessageDialog(null,"输入个数不合法", "请重新输入" , JOptionPane.WARNING_MESSAGE);flag3=0;};
int []flag=new int[count] ;
for (int m = 0; m < count; m++) {
flag[m]=0;
}
for(int i=0;i<count;i++) {
for (int j = 0; j < 17; j++) {
if(list[i].equals(check[j])) {
flag[i]=1;break;}
}
}
for(int i=0;i<count;i++) {
for (int k = 0; k < count; k++) {
if(flag[k]==0) {
JOptionPane.showMessageDialog(null,"输入中存在不合法项", "请重新输入" , JOptionPane.WARNING_MESSAGE);flag2=1;flag3=0;break;}
}if(flag2==1){
break;}System.out.println(list[i]);
//将光标移动到tf文本框
jtFou.requestFocus();
} if(flag3==1)
{
setVisible(false); //不用加this
dispose();//本窗口销毁,释放内存资源
new All();
}
}
//点击错误第一个直接获取这个方法
public void actionPerformed(ActionEvent e) {
String p=prinMain.jtf1.getText().toString();
int p1=Integer.parseInt(p);
if((JButton)e.getSource()==jbBack){
setVisible(false); //不用加this
dispose();//本窗口销毁,释放内存资源
new prinMain();
}
else if((JButton)e.getSource()==jbRandom)
{
jtFou.setText("");
int[][]arr;
String tf_str;
arr=new int [p1][5];
String[] c = {
"a","b","c","d","e","f"};
for(int j=0;j<p1;j++) {
for(int i=0; i<5; i++) {
arr[j][i] = (int)(Math.random()*16);
if(arr[j][i]<10) {
tf_str = String.valueOf(arr[j][i]);}
else {
int b=arr[j][i];b=b-10; tf_str = c[b];}
//将文本交给文本框
jtFou.setText(jtFou.getText()+tf_str);
//追加文本
//将光标移动到tf文本框
jtFou.requestFocus();
}
jtFou.setText(jtFou.getText()+",");
}
}
else if((JButton)e.getSource()==jbAll) {
clock(p1);
All.jTfou.setText(jtFou.getText());
}
else if((JButton)e.getSource()==jbPrint) {
setVisible(false);
new myprint();
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
prinNext prinnext=new prinNext();
for(int i=0;i<10;i++) {
for(int j=0;j<3;j++) {
ru[i][j]="";
}
}
}
}
第三、四张
package reqPage;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import backwork.FIFOthread;
import backwork.LRUthread;
import backwork.OPTthread;
public class All extends JFrame {
JButton jExit;
public static JButton jInitFIFO,jStartFIFO,jStopFIFO,jConFIFO;
public static JButton jInitLRU,jStartLRU,jStopLRU,jConLRU;
public static JButton jInitOPT,jStartOPT,jStopOPT,jConOPT;
public static JButton jSaveFIFO,jSaveLRU,jSaveOPT;
JLabel jl1,jl2,jl3;
JPanel jp0,jp1,jp2,jp3,jp4,jp5;
JRadioButton raFIFO,raLRU,raOPT;
public static JTextArea jTfou;//捕获逻辑页序列
public static JTextArea taFIFO;
public static JTextArea taLRU;
public static JTextArea taOPT;
JScrollPane jscrollPaneFI,jscrollPaneLR,jscrollPaneOP,jscro1;
public static int pageNum;//物理框个数
public static int quicktime;//访问快表时间
public static int slowtime;//访问页表（内存）时间
public static int changetime;//缺页中断处理时间
public static boolean flagFIFO,flagLRU,flagOPT;//单选框是否选中
String pstr2;
public static String[]input;//输入序列
int inputpage;
boolean SaFIFO=true;
boolean SaLRU=true;
boolean SaOPT=true;
/***********************/
//参数表中的东西要实例化的对象，即对象实例化（new）完再执行这个方法
public void mysetForTa(JTextArea ta) {
if(ta==taFIFO) {
ta.setText(" FIFO执行算法过程 \n");
}else if(ta==taLRU) {
ta.setText(" LRU执行算法过程 \n");
}else if(ta==taOPT) {
ta.setText(" OPT执行算法过程 \n");
}
ta.setText(ta.getText()+"逻辑页号"+" ");
for(int i=0;i<pageNum;i++) {
ta.setText(ta.getText()+"页框第"+(i+1)+"号"+" ");
}
ta.setText(ta.getText()+"是否缺页(√/X)"+" ");
ta.setText(ta.getText()+"执行时间(ms)"+"\n");
}
/********************/
public All() {
super("算法执行执行演变过程");
pstr2=prinMain.jtf2.getText().toString();
pageNum=Integer.parseInt(pstr2);//物理页框的个数
pstr2=prinMain.jtf3.getText().toString();
quicktime=Integer.parseInt(pstr2);
pstr2=prinMain.jtf4.getText().toString();
slowtime=Integer.parseInt(pstr2);
pstr2=prinMain.jtf5.getText().toString();
changetime=Integer.parseInt(pstr2);
raFIFO=new JRadioButton("使用快表",true);
raLRU=new JRadioButton("使用快表",true);
raOPT=new JRadioButton("使用快表",true);
//raFIFO.setEnabled(false);
jInitFIFO=new JButton("初始化");
jStartFIFO=new JButton("开始执行");
jStopFIFO=new JButton("暂停");
jConFIFO=new JButton("继续");
jInitLRU=new JButton("初始化");
jStartLRU=new JButton("开始执行");
jStopLRU=new JButton("暂停");
jConLRU=new JButton("继续");
jInitOPT=new JButton("初始化");
jStartOPT=new JButton("开始执行");
jStopOPT=new JButton("暂停");
jConOPT=new JButton("继续");
jSaveFIFO=new JButton("保存");
jSaveLRU=new JButton("保存");
jSaveOPT=new JButton("保存");
jExit=new JButton("返回");
jl1=new JLabel("FIFO:");
jl2=new JLabel("LRU:");
jl3=new JLabel("OPT:");
jTfou=new JTextArea();
jp0=new JPanel();
jp1=new JPanel();
jp2=new JPanel();
jp3=new JPanel();
jp4=new JPanel();
jp5=new JPanel();
//要在封装方法外实例化对象
taFIFO= new JTextArea();
taLRU= new JTextArea();
taOPT= new JTextArea();
taFIFO.setLineWrap(true);
taFIFO.setSize(200,300);
taLRU.setLineWrap(true);
taLRU.setSize(200,300);
taOPT.setLineWrap(true);
taOPT.setSize(200,300);
jTfou.setLineWrap(true);
taFIFO.setFont (new Font ("宋体", Font.PLAIN, 16));
taLRU.setFont (new Font ("宋体", Font.PLAIN, 16));
taOPT.setFont (new Font ("宋体", Font.PLAIN, 16));
jTfou.setFont (new Font ("宋体", Font.PLAIN, 18));
jscrollPaneFI=new JScrollPane(taFIFO);
jscrollPaneLR=new JScrollPane(taLRU);
jscrollPaneOP=new JScrollPane(taOPT);
jscro1=new JScrollPane(jTfou);
jp1.setLayout(new GridLayout(5,1,10,10));
jp1.add(jp0);
jp1.add(jp2);
jp1.add(jp3);
jp1.add(jp4);
jp1.add(jscro1);
jp0.add(jExit);
jp2.add(jl1);
jp2.add(raFIFO);
jp2.add(jInitFIFO);
jp2.add(jStartFIFO);
jp2.add(jStopFIFO);
jp2.add(jConFIFO);
jp2.add(jSaveFIFO);
jp3.add(jl2);
jp3.add(raLRU);
jp3.add(jInitLRU);
jp3.add(jStartLRU);
jp3.add(jStopLRU);
jp3.add(jConLRU);
jp3.add(jSaveLRU);
jp4.add(jl3);
jp4.add(raOPT);
jp4.add(jInitOPT);
jp4.add(jStartOPT);
jp4.add(jStopOPT);
jp4.add(jConOPT);
jp4.add(jSaveOPT);
setLayout(new GridLayout(4,1,10,10));
add(jp1);
add(jscrollPaneFI);
add(jscrollPaneLR);
add(jscrollPaneOP);
//按钮初始设置区
jStartFIFO.setEnabled(false);
jConFIFO.setEnabled(false);
jStopFIFO.setEnabled(false);
jStartLRU.setEnabled(false);
jConLRU.setEnabled(false);
jStopLRU.setEnabled(false);
jStartOPT.setEnabled(false);
jConOPT.setEnabled(false);
jStopOPT.setEnabled(false);
raFIFO.setEnabled(false);
raLRU.setEnabled(false);
raOPT.setEnabled(false);
jSaveFIFO.setEnabled(false);
jSaveLRU.setEnabled(false);
jSaveOPT.setEnabled(false);
//}
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(1000,1000);
this.setLocationRelativeTo(null);//在屏幕中间显示(居中显示)
setResizable(false);//re size able 为 false
setVisible(true);
//监听器
class action implements ActionListener{
FIFOthread t1=new FIFOthread();
LRUthread t2=new LRUthread();
OPTthread t3=new OPTthread();
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
String str=prinNext.jtFou.getText().toString();
String pstr=prinMain.jtf1.getText().toString();//获取第一个8
inputpage=Integer.parseInt(pstr);//逻辑页的个数
//声明数组长度为逻辑页数
input=new String[inputpage];
System.out.printf(str);
int n=0;
for(int i=0;i<str.length();i+=6) {
if(n>=inputpage){
break;}
input[n]=str.substring(i,i+5);
n++;
}
for(int i=0;i<inputpage;i++) {
System.out.printf("#"+input[i]+"\n");
}
//FIFO点击事件组
if((JButton)e.getSource()==jInitFIFO) {
raFIFO.setEnabled(true);//初始化后才可以选择是否使用快表
jStartFIFO.setEnabled(true);
jStopFIFO.setEnabled(false);
jInitFIFO.setEnabled(false);
jConFIFO.setEnabled(false);
jSaveFIFO.setEnabled(false);
t1.setStop(false);
t1.setGameover(true);
taFIFO.setText("");
mysetForTa(taFIFO);
}else if((JButton)e.getSource()==jStartFIFO){
flagFIFO=raFIFO.isSelected();
raFIFO.setEnabled(false);//开始后不能选择是否使用快表
jStartFIFO.setEnabled(false);
jInitFIFO.setEnabled(false);
jStopFIFO.setEnabled(true);
t1.setGameover(false);
Thread tt1=new Thread(t1,"线程1");
tt1.start();
}else if((JButton)e.getSource()==jStopFIFO) {
jStopFIFO.setEnabled(false);
jInitFIFO.setEnabled(true);
jConFIFO.setEnabled(true);
t1.setStop(true);
}else if((JButton)e.getSource()==jConFIFO) {
jConFIFO.setEnabled(false);
jInitFIFO.setEnabled(false);
jStopFIFO.setEnabled(true);
t1.setStop(false);
/*****************/
/*****************/
/*******************/
}else if((JButton)e.getSource()==jInitLRU) {
raLRU.setEnabled(true);
jStartLRU.setEnabled(true);
jStopLRU.setEnabled(false);
jInitLRU.setEnabled(false);
jConLRU.setEnabled(false);
jSaveLRU.setEnabled(false);
t2.setStop(false);
t2.setGameover(true);
taLRU.setText("");
mysetForTa(taLRU);
}else if((JButton)e.getSource()==jStartLRU){
flagLRU=raLRU.isSelected();
raLRU.setEnabled(false);
jStartLRU.setEnabled(false);
jInitLRU.setEnabled(false);
jStopLRU.setEnabled(true);
t2.setGameover(false);
Thread tt2=new Thread(t2,"线程2");
tt2.start();
}else if((JButton)e.getSource()==jStopLRU) {
jStopLRU.setEnabled(false);
jInitLRU.setEnabled(true);
jConLRU.setEnabled(true);
t2.setStop(true);
}else if((JButton)e.getSource()==jConLRU) {
jConLRU.setEnabled(false);
jInitLRU.setEnabled(false);
jStopLRU.setEnabled(true);
t2.setStop(false);
/***************/
/***************/
/***************/
}else if((JButton)e.getSource()==jInitOPT) {
raOPT.setEnabled(true);
jStartOPT.setEnabled(true);
jStopOPT.setEnabled(false);
jInitOPT.setEnabled(false);
jConOPT.setEnabled(false);
jSaveOPT.setEnabled(false);
t3.setStop(false);
t3.setGameover(true);
taOPT.setText("");
mysetForTa(taOPT);
}else if((JButton)e.getSource()==jStartOPT){
flagOPT=raOPT.isSelected();
raOPT.setEnabled(false);
jStartOPT.setEnabled(false);
jInitOPT.setEnabled(false);
jStopOPT.setEnabled(true);
t3.setGameover(false);
Thread tt3=new Thread(t3,"线程3");
tt3.start();
}else if((JButton)e.getSource()==jStopOPT) {
jStopOPT.setEnabled(false);
jInitOPT.setEnabled(true);
jConOPT.setEnabled(true);
t3.setStop(true);
}else if((JButton)e.getSource()==jConOPT) {
jConOPT.setEnabled(false);
jInitOPT.setEnabled(false);
jStopOPT.setEnabled(true);
t3.setStop(false);
/*************/
/*************/
/*************/
}else if((JButton)e.getSource()==jExit) {
//终结所有线程
t1.setStop(false);
t1.setGameover(true);
t2.setStop(false);
t2.setGameover(true);
t3.setStop(false);
t3.setGameover(true);
SaFIFO=true;
SaLRU=true;
SaOPT=true;
setVisible(false); //不用加this
//dispose();//本窗口销毁,释放内存资源
new prinNext();
}else if((JButton)e.getSource()==jSaveFIFO) {
//已经结束
if(SaFIFO==true) {
if(prinNext.prinNum>=10) {
JOptionPane.showMessageDialog(null,"保存失败！清单已满(容量:10)，请清空清单！", "请点击继续" , JOptionPane.WARNING_MESSAGE);
}
else {
prinNext.ru[prinNext.prinNum][0]=jTfou.getText().toString();
prinNext.ru[prinNext.prinNum][1]="FIFO";
prinNext.ru[prinNext.prinNum][2]=t1.getResult();
t1.setResult("");
prinNext.prinNum++;
}
jSaveFIFO.setEnabled(false);
SaFIFO=false;
}else {
JOptionPane.showMessageDialog(null,"程序结果已保存，请在清单中查看！！！", "请返回在清单中查看" , JOptionPane.WARNING_MESSAGE);
}
}else if((JButton)e.getSource()==jSaveLRU) {
//已经结束
if(SaLRU==true) {
if(prinNext.prinNum>=10) {
JOptionPane.showMessageDialog(null,"保存失败！清单已满(容量:10)，请清空清单！", "请点击继续" , JOptionPane.WARNING_MESSAGE);
}
else {
prinNext.ru[prinNext.prinNum][0]=jTfou.getText().toString();
prinNext.ru[prinNext.prinNum][1]="LRU";
prinNext.ru[prinNext.prinNum][2]=t2.getResult();
t2.setResult("");
prinNext.prinNum++;
}
jSaveLRU.setEnabled(false);
SaLRU=false;
}else {
JOptionPane.showMessageDialog(null,"程序结果已保存，请在清单中查看！！！", "请返回在清单中查看" , JOptionPane.WARNING_MESSAGE);
}
}else if((JButton)e.getSource()==jSaveOPT) {
//已经结束
if(SaOPT==true) {
if(prinNext.prinNum>=10) {
JOptionPane.showMessageDialog(null,"保存失败！清单已满(容量:10)，请清空清单！", "请点击继续" , JOptionPane.WARNING_MESSAGE);
}
else {
prinNext.ru[prinNext.prinNum][0]=jTfou.getText().toString();
prinNext.ru[prinNext.prinNum][1]="OPT";
prinNext.ru[prinNext.prinNum][2]=t3.getResult();
t3.setResult("");
prinNext.prinNum++;
}
jSaveOPT.setEnabled(false);
SaOPT=false;
}else {
JOptionPane.showMessageDialog(null,"程序结果已保存，请在清单中查看！！！", "请返回在清单中查看" , JOptionPane.WARNING_MESSAGE);
}
}
}
}
action act=new action();
jExit.addActionListener(act);
jInitFIFO.addActionListener(act);
jStartFIFO.addActionListener(act);
jStopFIFO.addActionListener(act);
jConFIFO.addActionListener(act);
jInitLRU.addActionListener(act);
jStartLRU.addActionListener(act);
jStopLRU.addActionListener(act);
jConLRU.addActionListener(act);
jInitOPT.addActionListener(act);
jStartOPT.addActionListener(act);
jStopOPT.addActionListener(act);
jConOPT.addActionListener(act);
jSaveFIFO.addActionListener(act);
jSaveLRU.addActionListener(act);
jSaveOPT.addActionListener(act);
}
/*********构造函数结束***********/
public static void main(String[] args) {
// TODO Auto-generated method stub
All all=new All();
}
}
保存结果清单
package reqPage;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class myprint extends JFrame{
JButton jback,jdele;
static JTextArea taPrint;
JScrollPane jsc;
JPanel jp1,jp2,jp3;
JLabel jl1;
public static void main(String[] args) {
// TODO Auto-generated method stub
myprint print=new myprint();
}
public myprint() {
jback=new JButton("返回");
jdele=new JButton("清空");
taPrint=new JTextArea();
taPrint.setText(" ");
taPrint.setLineWrap(true);
taPrint.setFont (new Font ("SansSerif", Font.PLAIN, 16));
//每次初始化
taPrint.setText("");
for(int i=0;i<prinNext.prinNum;i++) {
taPrint.setText(myprint.taPrint.getText()+"*******第"+(i+1)+"组结果如下:*********\n");
taPrint.setText(myprint.taPrint.getText()+"逻辑地址序列:\n"+prinNext.ru[i][0]+"\n");
taPrint.setText(myprint.taPrint.getText()+prinNext.ru[i][1]+"变换物理地址序列:\n"+prinNext.ru[i][2]+"\n"+"\n");
}
jsc=new JScrollPane(taPrint);
jp1=new JPanel();
jp2=new JPanel();
jp3=new JPanel();
jl1=new JLabel("程序结果清单");
jl1.setFont(new Font("微软雅黑", Font.BOLD, 24));
jp1.add(jback);
jp1.add(jdele);
jp2.add(jl1);
jp3.setLayout(new GridLayout(2,1));
jp3.add(jp2);
jp3.add(jp1);
setLayout(new GridLayout(2,1));
this.add(jp3);
this.add(jsc);
action act=new action();
jback.addActionListener(act);
jdele.addActionListener(act);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(800,600);
this.setLocationRelativeTo(null);//在屏幕中间显示(居中显示)
setResizable(false);//re size able 为 false
setVisible(true);
}
class action implements ActionListener{
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if((JButton)e.getSource()==jback) {
setVisible(false);
dispose();
new prinNext();
}else if((JButton)e.getSource()==jdele) {
taPrint.setText("");
//把数量变为0
prinNext.prinNum=0;
}
}
}
}
多线程部分
FIFOthread
package backwork;
import java.util.LinkedList;
import java.util.Queue;
import reqPage.All;
public class FIFOthread implements Runnable{
private boolean stop=false;//用于暂停线程！！！！（私有成员）
private String control=" ";//随便设(!!!!但是多个线程类中每个内容不同，)，用于共用资源！！！！（object类）
private boolean gameover=false;//用于直接退出线程
private String result="";//用于存储结果
char []ar;//快慢表
//对成员stop赋值的公有成员方法（通过 [类.方法]来使用）
public void setStop(boolean stop) {
//当stop为false时，恢复所有线程
if(!stop) {
//通过占有一个资源来实现同步
synchronized (control) {
control.notify();
}
}
this.stop=stop;
}
public void setGameover(boolean gameover) {
this.gameover=gameover;
}
//用它来知道结束与否
public boolean getGameover() {
return this.gameover;
}
//用它来存结果
public String getResult() {
return this.result;
}
public void setResult(String result) {
this.result=result;
}
public void run() {
int quickt=All.quicktime,slowt=All.slowtime,quet=All.changetime;//访问快表，慢表，缺页处理时间
System.out.print("（1）线程1启动");
// TODO Auto-generated method stub
Queue<Integer> queue = new LinkedList<>();//<>中填入的是整形类，都是包装类！！！
ar=new char[All.pageNum];
//初始化
for(int i=0;i<All.pageNum;i++) {
ar[i]=' ';
}
boolean flag;//是否查询到
boolean pageFull;//是否满页
int sum=0;
for(int i=0;i<All.input.length;i++) {
///每次运行到这里的时候，都判断stop，当为true时候，卡住资源（wait），等待notify的执行来释放它
synchronized (control) {
while(stop) {
try {
control.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/
/先判断是否大退
if(gameover) {
break;
}
sum=0;
System.out.print("（1）执行第"+i+"次循环\n");
char ch=All.input[i].charAt(0);//获取字符串相应位置的字符
//先查快表与慢表
flag=false;
for(int a=0;a<All.pageNum;a++) {
if(ar[a]==ch) {
flag=true;
break;
}
}
if(flag==true) {
System.out.print("（1）找到了并打印\n");
if(All.flagFIFO==true) {
sum=quickt+slowt;//在表中找到快表+访问内存时间
}else {
sum=slowt+slowt;
}
printer(ch,false,sum,All.input[i]);
continue;//结束本层循环，这里之前用了break,直接跳出了
}
//执行缺页中断
//1、有空页
pageFull=true;//初始化
for(int b=0;b<All.pageNum;b++) {
if(ar[b]==' ') {
ar[b]=ch;
queue.add(b);//加入到队列中
pageFull=false;
break;
}
}
//2、满页执行置换算法（FIFO）
if(pageFull==true) {
System.out.printf("（1）执行了满页置换\n");
ar[queue.peek()]=ch;//peek当队列空的时候返回null
queue.add(queue.peek());//将队首放回队尾
queue.poll();//删除队首（null）,remove
}
if(All.flagFIFO==true) {
sum=quickt+slowt+quet+quickt+slowt;//执行缺页中断的时间
}else {
sum=slowt+quet+slowt+slowt;
}
printer(ch,true,sum,All.input[i]);
System.out.print("（1）执行了缺页后打印\n");
}
//清空队列
queue.clear();
this.gameover=true;
All.jStopFIFO.setEnabled(false);
All.jInitFIFO.setEnabled(true);
All.jSaveFIFO.setEnabled(true);
}
//打印输出
public void printer(char ch,boolean que,int sum,String str) {
//每次打印的时候对result赋值
for(int t=0;t<All.pageNum;t++) {
if(ch==ar[t]) {
this.result+=(t+1)+str.substring(1)+",";
}
}
/
System.out.print("（1）"+ch+"如下\n");
All.taFIFO.setText(All.taFIFO.getText()+ch+" ");
for(int a=0;a<All.pageNum;a++) {
System.out.print("（1）"+ar[a]+"\n");
All.taFIFO.setText(All.taFIFO.getText()+ar[a]+" ");
}
if(que==true) {
All.taFIFO.setText(All.taFIFO.getText()+"√"+" ");
}else {
All.taFIFO.setText(All.taFIFO.getText()+"×"+" ");
}
All.taFIFO.setText(All.taFIFO.getText()+sum+"\n");
try {
Thread.sleep(1000);//1秒延迟实现动态显示
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
LRUthread
package backwork;
import java.util.LinkedList;
import java.util.Queue;
import reqPage.All;
public class LRUthread implements Runnable {
private boolean stop=false;//用于停止线程
private String control1=" oooo";//随便设(!!!!但是多个线程类中每个内容不同，)，用于共用资源
private boolean gameover=false;
private String result="";//用于存储结果
char ar[];
//
public void setStop(boolean stop) {
if(!stop) {
synchronized (control1) {
control1.notify();
}
}
this.stop=stop;
}
public void setGameover(boolean gameover) {
this.gameover=gameover;
}
//用它来知道结束与否
public boolean getGameover() {
return this.gameover;
}
//用它来存结果
public String getResult() {
return this.result;
}
public void setResult(String result) {
this.result=result;
}
public void run() {
int quickt=All.quicktime,slowt=All.slowtime,quet=All.changetime;//访问快表，慢表，缺页处理时间
System.out.print("（2）线程启动");
// TODO Auto-generated method stub
ar=new char[All.pageNum];
//初始化
for(int i=0;i<All.pageNum;i++) {
ar[i]=' ';
}
Queue<Character> queue = new LinkedList<>();//用于LRU算法的实现
Queue<Character> queue2 = new LinkedList<>();//用于LRU算法中的替换
char ch;
boolean flag;//是否查到
boolean full;//是否页满
int sum=0;
for(int i=0;i<All.input.length;i++) {
///
synchronized (control1) {
while(stop) {
try {
control1.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/
/后判断是否大退
if(gameover) {
break;
}
/
//每次循环开始都要初始化
sum=0;
System.out.printf("（2）第"+i+"次循环\n");
ch=All.input[i].charAt(0);
flag=false;
for(int a=0;a<All.pageNum;a++) {
if(ch==ar[a]) {
flag=true;
System.out.printf("（2）在页表中查到");
///
//只有ch在表中，及访问到表中数据（查到）后才会进行调整，当要置换时候，新的页号放到到此时队列首元素的页框号，之后将队首出队，他入队
//对队列进行调整
while(!queue.isEmpty()){
if(queue.peek()!=ch) {
queue2.add(queue.peek());//将q1送入q2
}
queue.poll();
}
while(!queue2.isEmpty()) {
queue.add(queue2.peek());
queue2.poll();
}
queue.add(ch);
queue2.clear();
///
break;
}
}
//已经查到直接跳啊到下一次循环
if(flag==true){
if(All.flagLRU==true) {
sum=quickt+slowt;//在表中找到快表+访问内存时间
}else {
sum=slowt+slowt;
}
printer(ch,false,sum,All.input[i]);
continue;
}
//没有查到
full=true;
//页表未满
for(int b=0;b<All.pageNum;b++) {
if(ar[b]==' ') {
System.out.printf("（2）执行页表未满缺页处理\n");
ar[b]=ch;
full=false;
queue.add(ch);
break;
}
}
//页满执行置换算法
if(full==true) {
System.out.print("（2）页满置换缺页处理\n");
//找到最久页对应的页框，然后换上新的页
for(int c=0;c<All.pageNum;c++) {
if(ar[c]==queue.peek()) {
ar[c]=ch;
break;
}
}
//调整队列
queue.poll();
queue.add(ch);
}
if(All.flagLRU==true) {
sum=quickt+slowt+quet+quickt+slowt;//执行缺页中断的时间
}else {
sum=slowt+quet+slowt+slowt;
}
printer(ch,true,sum,All.input[i]);
}
queue.clear();
this.gameover=true;//当线程执行完成后over
//暂停灭，初始化亮，保存亮
All.jStopLRU.setEnabled(false);
All.jInitLRU.setEnabled(true);
All.jSaveLRU.setEnabled(true);
}
//打印
public void printer(char ch,boolean que,int sum,String str) {
//每次打印的时候对result赋值
for(int t=0;t<All.pageNum;t++) {
if(ch==ar[t]) {
this.result+=(t+1)+str.substring(1)+",";
}
}
/
System.out.print("（2）"+ch+"如下\n");
All.taLRU.setText(All.taLRU.getText()+ch+" ");
for(int a=0;a<All.pageNum;a++) {
System.out.print("（1）"+ar[a]+"\n");
All.taLRU.setText(All.taLRU.getText()+ar[a]+" ");
}
if(que==true) {
All.taLRU.setText(All.taLRU.getText()+"√"+" ");
}else {
All.taLRU.setText(All.taLRU.getText()+"×"+" ");
}
All.taLRU.setText(All.taLRU.getText()+sum+"\n");
try {
Thread.sleep(1000);//1秒延迟实现动态显示
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
OPTthread
package backwork;
import reqPage.All;
public class OPTthread implements Runnable{
private boolean stop=false;//用于暂停线程！！！！（私有成员）
private String control2=" 2222";//随便设(!!!!但是多个线程类中每个内容不同，)，用于共用资源！！！！（object类）
private boolean gameover=false;//用于直接退出线程
private String result="";//用于存储结果
char []ar;//快慢表
//对成员stop赋值的公有成员方法（通过 [类.方法]来使用）
public void setStop(boolean stop) {
//当stop为false时，恢复所有线程
if(!stop) {
//通过占有一个资源来实现同步
synchronized (control2) {
control2.notify();
}
}
this.stop=stop;
}
public void setGameover(boolean gameover) {
this.gameover=gameover;
}
//用它来知道结束与否
public boolean getGameover() {
return this.gameover;
}
//用它来存结果
public String getResult() {
return this.result;
}
public void setResult(String result) {
this.result=result;
}
public void run()
{
ar=new char[All.pageNum];
//初始化
int quickt=All.quicktime,slowt=All.slowtime,quet=All.changetime;//访问快表，慢表，缺页处理时间
for(int i=0;i<All.pageNum;i++) {
ar[i]=' ';
}
char []ob=new char [All.input.length];
for(int x=0;x<All.input.length;x++)
{
ob[x]=All.input[x].charAt(0);
}
char ch;
boolean flag;
boolean full;
boolean que;
//设置总时间
int sum=0;
for(int i=0;i<All.input.length;i++)
{
///每次运行到这里的时候，都判断stop，当为true时候，卡住资源（wait），等待notify的执行来释放它
synchronized (control2) {
while(stop) {
try {
control2.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/
/先判断是否大退
if(gameover) {
break;
}
//
//每次循环初始化sum
sum=0;
ch=All.input[i].charAt(0);
flag=false;
que=false;//缺页
for(int a=0;a<All.pageNum;a++)
{
if(ch==ar[a])
{
flag=true;
if(All.flagOPT==true) {
sum=quickt+slowt;//在表中找到快表+访问内存时间
}else {
sum=slowt+slowt;
}
break;
}
}
if(flag==true)
{
printer(ch,que,sum,All.input[i]);
continue;
}
full=true;
for(int b=0;b<All.pageNum;b++)
{
if(ar[b]==' ')
{
ar[b]=ch;
full=false;
que=true;
if(All.flagOPT==true) {
sum=quickt+slowt+quet+quickt+slowt;//执行缺页中断的时间
}else {
sum=slowt+quet+slowt+slowt;
}
break;
}
}
if(full) {
que=true;
int[] ohh=new int[All.pageNum];
for(int j=0;j<All.pageNum;j++) {
ohh[j]=0;
for(int nn=i+1;nn<All.input.length;nn++) {
ohh[j]++;
if(ar[j]==ob[nn]) {
break;
}
}
System.out.print(ohh[j]);
}
int fari = 0,far=-1;
for(int j=0;j<All.pageNum;j++) {
if(ohh[j]>far) {
far=ohh[j];
fari=j;
}
}
ar[fari]=ch;
sum=quickt+slowt+quet+quickt+slowt;//执行缺页中断的时间
}
printer(ch,que,sum,All.input[i]);
}
this.gameover=true;
All.jStopOPT.setEnabled(false);
All.jInitOPT.setEnabled(true);
All.jSaveOPT.setEnabled(true);
}
public void printer(char ch,boolean que,int sum,String str) {
//每次打印的时候对result赋值
for(int t=0;t<All.pageNum;t++) {
if(ch==ar[t]) {
this.result+=(t+1)+str.substring(1)+",";
}
}
/
All.taOPT.setText(All.taOPT.getText()+ch+" ");
for(int a=0;a<All.pageNum;a++) {
All.taOPT.setText(All.taOPT.getText()+ar[a]+" ");
}
if(que==true)//判断是否缺页
{
All.taOPT.setText(All.taOPT.getText()+"√"+" ");
}else {
All.taOPT.setText(All.taOPT.getText()+"×"+" ");
}
All.taOPT.setText(All.taOPT.getText()+sum+"\n");
try {
Thread.sleep(1000);//1秒延迟实现动态显示
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
代码有很多冗余，但是过了课设，项目本身没问题
下载链接：//download.csdn.net/download/qq_44195558/12102023