合工大页面置换算法操作系统课程设计报告


    








    计算机信息学院

    操作系统综合设计报告







    设计题目:页面置换算法

    学生姓名:

    学 号:

    专业班级:计算机科学技术班





















    2015 年 X月
    设计题目 3

    二开发环境工具 3

    三设计原理 3

    1佳(Optimal)置换算法 3

    2先进先出(FIFO)页面置换算法 4

    3久未(LRU)页面置换算法 4

    四重算法 5

    1算法流程图 5

    2 关键代码 8

    五设计结果 22

    六设计体会 24

    七附录 24



    设计题目
    第15题:页面置换算法
    1 建立相应数结构
    2 屏幕显示页面状况
    3 时间流逝面种方法模拟:
    (a) 键盘次认时间单位
    (b) 相应WM_TIMER
    4 批页置换情况存入磁盘文件读出重放
    5 计算页面缺页次数缺页页面置换次数
    6 支持算法:FIFOLRU佳置换算法


    二开发环境工具
    开发环境:Windows
    开发工具:VC60 Eclipse

    三设计原理
    1佳(Optimal)置换算法
    佳置换算法Belady1966年提出种理算法选择淘汰页面永未长时间访问页面采佳置换算法通常保证获低缺页率目前法预知进程存干页面中页面未长时间访问该算法法实现该算法评价算法现举例说明:
    假定系统某进程分配三物理快考虑页面号引串:
    7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
    进程运行时先701三页面放入存进程访问页面2时会产生缺页中断时OS根佳置换算法选择页面7予淘汰页面0作第5访问页面页面1第14访问页面页面7第18次页面访问需调入次访问页面0时已存必产生缺页中断进程访问页面3时讲引起页面1淘汰现120三页面中晚访问图1示出采佳置换算法时置换图图出采佳置换算法发生6次页面置换

    页面号
    7
    0
    1
    2
    0
    3
    0
    4
    2
    3
    0
    3
    2
    1
    2
    0
    1
    7
    0
    1
    物理快1
    7
    7
    7
    2

    2

    2


    2


    2



    7


    物理快2

    0
    0
    0

    0

    4


    0


    0



    0


    物理快3


    1
    1

    3

    3


    3


    1



    1



    2先进先出(FIFO)页面置换算法
    FIFO算法早出现置换算法该算法总淘汰先进入存页面选择存中驻留时间长页面予淘汰该算法实现简单需已调入存页面先次序排成队列发生缺页时队首页面出队找页面入队样完成页面置换务书例表格:

    7 0 1 2 0 3 4 2 3 0 3 2 1 2 0 1 7 0
    7
    7
    7
    2
    2
    2
    4
    4
    4
    0
    0
    0
    0
    0
    0
    0
    7
    7

    0
    0
    0
    0
    3
    3
    2
    2
    2
    2
    2
    1
    1
    1
    1
    1
    0


    1
    1
    1
    1
    0
    0
    3
    3
    3
    3
    3
    2
    2
    2
    2
    2

    该算法程序运行规律相适应忽视程序运行局部性原理造成需访问页面常性置换

    3久未(LRU)页面置换算法
    FIFO算法性较差根页面进入先次序进行置换反映页面情况久未(LRU)算法基思想利预测未根程序运行局部性原理佳置换算法理价值实际系统中法利预测未该算法访问字段记录次访问历时间t需淘汰页面时选择页面中t值久未页面予置换
    书例表格:
    7 0 1 2 0 3 4 2 3 0 3 2 1 2 0 1 7 0
    7
    7
    7
    2
    2
    2
    4
    4
    4
    0
    0
    0
    1
    1
    1
    1
    1
    1

    0
    0
    0
    0
    0
    0
    0
    3
    3
    3
    3
    3
    3
    0
    0
    0
    0


    1
    1
    1
    3
    3
    2
    2
    2
    2
    2
    2
    2
    2
    2
    7
    7

    四重算法
    1算法流程图
    FIFO算法流程图:
    Y
    i++
    p[i]容直接装入面空存块i++
    page[]中先装入页面置换出i++
    Page[]否空
    前p[]中第i元素否已存中
    页面走存入数组p[]中存块page[]表示初始化0
    开始








    N


    Y
    N





    输出前存块状态



    结束





    LRU算法流程图:

    开始



    页面走存入数组p[]中存块page[]表示初始化0


    Y
    前p[]中第i元素否已存

    i++


    N

    N
    Page[]否空

    Y

    结束

    p[i]容直接装入面空存块i++
    输出前存块状态
    page[]中久未页面置换出i++







    OPT算法流程图:
    开始

    Y
    i++
    结束
    输出前存块状态
    page[]中段时间时间离现远换出i++
    p[i]容直接装入面空存块i++
    Page[]否空
    前p[]中第i元素否已存
    页面走存入数组p[]中存块page[]表示初始化0






    N


    N

    Y










    2 关键代码
    1 FIFO算法代码:
    public class FIFOControl {
    private int[] num {70120304230321201701}参构造函数
    private int[] num new int[50]
    private int numLength
    private int[] pg new int[10]
    private int[] timepg new int[10]
    private int PageNum
    public int[][] store

    FIFOControl()
    {
    thisPageNum 3
    numLength 20
    int[] numtemp {70120304230321201701}
    for( int i 0 i < numLength i++ )
    {
    num[i] numtemp[i]
    }
    for(int i 0 i < 10 i++)
    {
    pg[i] 1
    timepg[i] 1
    }
    store new int[numLength][PageNum+1]
    for( int i 1 i < PageNum+1 i++)
    {
    for( int j 0 j < numLength j++ )
    {
    store[j][i] 1
    }
    }
    for( int k 0 k < numLength k++ )
    {
    store[k][0] 0
    }
    }

    FIFOControl( int nump int[] n int nlength )参数:1物理块数 2页面序列号 3页面序列号数组长度 meiyong
    {
    thisPageNum nump
    numLength nlength
    for(int j 0 j < nlength j++)
    {
    num[j] n[j]
    }
    for(int i 0 i < 10 i++)
    {
    pg[i] 1
    timepg[i] 1
    }
    store new int[numLength][PageNum+1]
    for( int i 1 i < PageNum+1 i++)
    {
    for( int j 0 j < numLength j++ )
    {
    store[j][i] 1
    }
    }
    for( int k 0 k < numLength k++ )
    {
    store[k][0] 0
    }
    }

    private boolean checkInPage( int[] p int plength int keynum )
    {
    for( int jj 0 jj < plength jj++)
    {
    timepg[jj]++
    }
    for(int j 0 j < plength j++)
    {
    if( keynum p[j] )
    {
    return true
    }
    }
    return false
    }

    private void caculate()
    {
    物理页框装满
    int timer 0横着指针
    for( int i 0 i < PageNum i++ )
    {
    pg[i] num[i]
    for( int j 0 j < i j++)加时间
    {
    timepg[j]++
    }
    for(int jj 0 jj < PageNum jj++)数放store中
    {
    store[timer][jj+1] pg[jj]
    }
    timer++
    }
    面数先进先出序放物理块中
    for( int i PageNum i < numLength i++ )
    {
    if( checkInPage( pg PageNum num[i] ) )果物理框中应位时间置1
    {
    for(int j 0 j < PageNum j++)次物理块中数存储起
    {
    store[timer][j+1] pg[j]
    }
    timer++
    }
    else否找出时间长置换应位时间置1
    {
    int max timepg[0]
    int maxvalue pg[0]
    int maxindex 0
    int temp
    for( int n 1 n < PageNum n++ )找时间物理块
    {
    temp timepg[n]
    if( temp > max )
    {
    max temp
    maxvalue pg[n]
    maxindex n
    }
    }
    Systemoutprintln( max + max )
    Systemoutprintln( maxindex + maxindex )
    pg[maxindex] num[i]
    timepg[maxindex] 1
    for(int j 0 j < PageNum j++)次数存储起
    {
    store[timer][j+1] pg[j]
    }
    store[timer][0] maxindex+1
    timer++
    }
    }
    测试查结果
    for( int i 0 i < PageNum+1 i++)se shi
    {
    for( int j 0 j < numLength j++ )
    {
    Systemoutprint(store[j][i] + )
    }
    Systemoutprintln()
    }
    }

    public int[][] getStore()
    {
    thiscaculate()
    return store
    }public class FIFOControl {
    private int[] num {70120304230321201701}参构造函数
    private int[] num new int[50]
    private int numLength
    private int[] pg new int[10]
    private int[] timepg new int[10]
    private int PageNum
    public int[][] store

    FIFOControl()
    {
    thisPageNum 3
    numLength 20
    int[] numtemp {70120304230321201701}
    for( int i 0 i < numLength i++ )
    {
    num[i] numtemp[i]
    }
    for(int i 0 i < 10 i++)
    {
    pg[i] 1
    timepg[i] 1
    }
    store new int[numLength][PageNum+1]
    for( int i 1 i < PageNum+1 i++)
    {
    for( int j 0 j < numLength j++ )
    {
    store[j][i] 1
    }
    }
    for( int k 0 k < numLength k++ )
    {
    store[k][0] 0
    }
    }

    FIFOControl( int nump int[] n int nlength )参数:1物理块数 2页面序列号 3页面序列号数组长度 meiyong
    {
    thisPageNum nump
    numLength nlength
    for(int j 0 j < nlength j++)
    {
    num[j] n[j]
    }
    for(int i 0 i < 10 i++)
    {
    pg[i] 1
    timepg[i] 1
    }
    store new int[numLength][PageNum+1]
    for( int i 1 i < PageNum+1 i++)
    {
    for( int j 0 j < numLength j++ )
    {
    store[j][i] 1
    }
    }
    for( int k 0 k < numLength k++ )
    {
    store[k][0] 0
    }
    }

    private boolean checkInPage( int[] p int plength int keynum )
    {
    for( int jj 0 jj < plength jj++)
    {
    timepg[jj]++
    }
    for(int j 0 j < plength j++)
    {
    if( keynum p[j] )
    {
    return true
    }
    }
    return false
    }

    private void caculate()
    {
    物理页框装满
    int timer 0横着指针
    for( int i 0 i < PageNum i++ )
    {
    pg[i] num[i]
    for( int j 0 j < i j++)加时间
    {
    timepg[j]++
    }
    for(int jj 0 jj < PageNum jj++)数放store中
    {
    store[timer][jj+1] pg[jj]
    }
    timer++
    }
    面数先进先出序放物理块中
    for( int i PageNum i < numLength i++ )
    {
    if( checkInPage( pg PageNum num[i] ) )果物理框中应位时间置1
    {
    for(int j 0 j < PageNum j++)次物理块中数存储起
    {
    store[timer][j+1] pg[j]
    }
    timer++
    }
    else否找出时间长置换应位时间置1
    {
    int max timepg[0]
    int maxvalue pg[0]
    int maxindex 0
    int temp
    for( int n 1 n < PageNum n++ )找时间物理块
    {
    temp timepg[n]
    if( temp > max )
    {
    max temp
    maxvalue pg[n]
    maxindex n
    }
    }
    Systemoutprintln( max + max )
    Systemoutprintln( maxindex + maxindex )
    pg[maxindex] num[i]
    timepg[maxindex] 1
    for(int j 0 j < PageNum j++)次数存储起
    {
    store[timer][j+1] pg[j]
    }
    store[timer][0] maxindex+1
    timer++
    }
    }
    }

    public int[][] getStore()
    {
    thiscaculate()
    return store
    }
    2 LRU算法代码:
    public class LRUControl {
    private int[] num {70120304230321201701}参构造函数
    private int[] num new int[50]参构造函数
    private int numLength
    private int PageNum
    private Page[] pg new Page[10]
    public int[][] store
    public int[][] temp1


    LRUControl()
    {
    PageNum 3
    numLength numlength
    store new int[numLength][PageNum]

    for( int i 0 i {
    pg[i] new Page()
    if( thispg[i] null )
    {
    thispg[i]setValue(1)
    thispg[i]setTime(0)
    }
    else
    {
    Systemoutprintln( 象创建失败 +\\r\\n)
    }
    }
    }

    LRUControl( int nump int[] n int nlength )参数:1物理块数 2页面序列号 3页面序列号数组长度 meiyong
    {
    thisPageNum nump
    numLength nlength
    for(int j 0 j < nlength j++)
    {
    num[j] n[j]
    }
    store new int[numLength][PageNum+1]gai dong
    temp1 new int[numLength][PageNum+1]

    for( int i 0 i {
    pg[i] new Page()
    if( thispg[i] null )
    {
    thispg[i]setValue(1)
    thispg[i]setTime(0)
    }
    else
    {
    Systemoutprintln( 象创建失败 +\\r\\n)
    }
    }


    }

    private boolean checkInPage( Page[] p int plength int keynum )
    {
    for( int jj 0 jj < plength jj++)
    {
    p[jj]setTime( p[jj]getTime()+1 )
    }

    for(int j 0 j < plength j++)
    {
    if( keynum p[j]getValue() )
    {
    return true
    }
    }
    return false
    }

    void caculate()
    {
    int timer 0
    前PageNum先物理快装满
    for( int i 0 i < PageNum i++ )
    {
    pg[i]setValue( num[i] )
    pg[i]setTime( 1 )
    for( int j 0 j < i j++)
    {
    pg[j]setTime( pg[j]getTime()+1 )
    }
    for(int j 0 j < PageNum j++)
    {
    store[timer][j] pg[j]getValue()
    }
    timer++
    }
    for( int i 0 i < PageNum i++)
    {
    store[i][PageNum] 0
    }
    num数组面页面检查否前面出现置该页框时间1没原基础加1
    for( int i PageNum i < numLength i++ )
    {
    if( checkInPage( pg PageNum num[i] ) )果物理框中应位时间置1
    {
    for( int m 0 m < PageNum m++ )num[i]pg[]中相等物理块时间置1
    {
    if( num[i] pg[m]getValue() )
    {
    pg[m]setTime(1)
    break
    }
    }
    for(int j 0 j < PageNum j++)次物理块中数存储起
    {
    store[timer][j] pg[j]getValue()
    }
    store[timer][PageNum] 0
    timer++
    }
    else否找出时间长置换应位时间置1
    {
    int max pg[0]getTime()
    int maxindex 0
    int temp
    for( int n 1 n < PageNum n++ )找时间物理块
    {
    temp pg[n]getTime()
    if( temp > max )
    {
    max temp
    maxindex n
    }
    }
    Systemoutprintln( max + max )
    Systemoutprintln( maxindex + maxindex )
    pg[maxindex]setTime(1)
    pg[maxindex]setValue(num[i])
    for(int j 0 j < PageNum j++)次数存储起
    {
    store[timer][j] pg[j]getValue()
    }
    store[timer][PageNum] maxindex+1
    timer++
    }
    }
    }

    void display()
    {
    for( int i 0 i {
    for(int j 0 j < numLength j++)
    {
    Systemoutprint( store[j][i] + )
    }
    Systemoutprintln()
    }
    }

    private void adjustStore()
    {
    for( int i 1 i {
    for(int j 0 j < numLength j++)
    {
    temp1[j][i] store[j][i1]
    }
    }
    for(int k 0 k < numLength k++)
    {
    temp1[k][0] store[k][PageNum]
    }
    }

    public int[][] getStore()
    {
    adjustStore()
    return temp1
    }

    }
    3 OPT算法代码:
    int Optimal(int page[] int page_num int memory_num int process[][]){参数(访问页面数组访问页面总数存块数)

    int max 未长时间访问页面距次访问时间
    int max_page 未长时间访问页面号
    int memory_null 存中空位号(没空位时1)
    int lack 0 记录缺页次数
    int[][] process new int[50][50]记录置换程

    Memory[] memory new Memory[10] 创建存

    记录置换程数组初始化
    for(int a0a for(int b0b process[a][b] 1
    }
    }

    存块初始化
    for(int m0m memory[m] new Memory()
    memory[m]page 1
    memory[m]next 0
    }

    for(int i0i Systemoutprintln(\n读取+page[i])
    if(isMemory(page[i] memory memory_num)){页面已存中
    Systemoutprintln(页面已存中)
    记录
    process[0][i] 0没置换
    for(int n1n process[n][i] process[n][i1]
    }

    }else{ 页面存中

    memory_null isNull(memory memory_num)获取存中空位号(没空位时1)

    if(memory_null1){ [存中没空位]
    获取存块中页面距次访问时间
    for(int j0j memory[j]next nextAccess(memory[j]page page page_num i)
    }
    输出存块中页面距次访问时间
    Systemoutprint(next)
    for(int y0y Systemoutprint(memory[y]next+ )
    }
    Systemoutprintln()

    获取未长时间访问页面号
    max memory[0]next
    max_page 0
    for(int j0j if(memory[j]next>max){
    max memory[j]next
    max_page j
    }
    }
    未长时间访问页面号置换新页面
    Systemoutprintln(置换+memory[max_page]page+>+page[i])
    memory[max_page]page page[i]置换

    lack++更新缺页次数

    记录
    process[0][i] max_page+1发生置换
    process[max_page+1][i] page[i]
    for(int n1n if(nmax_page+1){
    process[n][i] process[n][i1]
    }
    }

    }else { [存中空位]
    Systemoutprintln(存中空位+memory_null)
    memory[memory_null]page page[i]
    新页面放入存块空位中
    for(int x0x Systemoutprint(memory[x]page+ )
    }
    Systemoutprintln()

    记录
    process[0][i] 0没置换
    process[memory_null+1][i] page[i]
    for(int n1n if(nmemory_null+1){
    if(i>0){
    process[n][i] process[n][i1]
    }else{
    process[n][i] 1
    }
    }
    }
    }

    }
    }

    Systemoutprintln(\n缺页数+lack)
    Systemoutprintln(缺页率+(double)lackpage_num)

    Systemoutprintln(佳页面置换算法置换表)
    for(int a0a for(int b0b Systemoutprint(process[a][b]+ )
    }
    Systemoutprintln()
    }

    return 0
    }
    五设计结果

    图1 页面号文件

    图2 读入页面号


    图3 动运行


    图4 单步运行


    六设计体会
    次课程设计仅操作系统门课程更深入研究重概念巩固掌握通努力三页面置换算法程序已完成然做少够完善毕竟努力结果点收获:
    1通网书查阅相关资料JAVA语言基框架新解加深视化程序认识
    2Java语言实现功时语言较简练更容易理解实性强
    3先进先出页面置换LRUOPT算法特点实践起页面置换算法新认识
    外学合作收获许做界面短板学强项合作方面收获学少东西


    七附录
    代码:(总4Java文件)

    FIFOControljava

    public class FIFOControl {
    private int[] num {70120304230321201701}参构造函数
    private int[] num new int[50]
    private int numLength
    private int[] pg new int[10]
    private int[] timepg new int[10]
    private int PageNum
    public int[][] store

    FIFOControl()
    {
    thisPageNum 3
    numLength 20
    int[] numtemp {70120304230321201701}
    for( int i 0 i < numLength i++ )
    {
    num[i] numtemp[i]
    }
    for(int i 0 i < 10 i++)
    {
    pg[i] 1
    timepg[i] 1
    }
    store new int[numLength][PageNum+1]
    for( int i 1 i < PageNum+1 i++)
    {
    for( int j 0 j < numLength j++ )
    {
    store[j][i] 1
    }
    }
    for( int k 0 k < numLength k++ )
    {
    store[k][0] 0
    }
    }

    FIFOControl( int nump int[] n int nlength )参数:1物理块数 2页面序列号 3页面序列号数组长度 meiyong
    {
    thisPageNum nump
    numLength nlength
    for(int j 0 j < nlength j++)
    {
    num[j] n[j]
    }
    for(int i 0 i < 10 i++)
    {
    pg[i] 1
    timepg[i] 1
    }
    store new int[numLength][PageNum+1]
    for( int i 1 i < PageNum+1 i++)
    {
    for( int j 0 j < numLength j++ )
    {
    store[j][i] 1
    }
    }
    for( int k 0 k < numLength k++ )
    {
    store[k][0] 0
    }
    }

    private boolean checkInPage( int[] p int plength int keynum )
    {
    for( int jj 0 jj < plength jj++)
    {
    timepg[jj]++
    }
    for(int j 0 j < plength j++)
    {
    if( keynum p[j] )
    {
    return true
    }
    }
    return false
    }

    private void caculate()
    {
    物理页框装满
    int timer 0横着指针
    for( int i 0 i < PageNum i++ )
    {
    pg[i] num[i]
    for( int j 0 j < i j++)加时间
    {
    timepg[j]++
    }
    for(int jj 0 jj < PageNum jj++)数放store中
    {
    store[timer][jj+1] pg[jj]
    }
    timer++
    }
    面数先进先出序放物理块中
    for( int i PageNum i < numLength i++ )
    {
    if( checkInPage( pg PageNum num[i] ) )果物理框中应位时间置1
    {
    for(int j 0 j < PageNum j++)次物理块中数存储起
    {
    store[timer][j+1] pg[j]
    }
    timer++
    }
    else否找出时间长置换应位时间置1
    {
    int max timepg[0]
    int maxvalue pg[0]
    int maxindex 0
    int temp
    for( int n 1 n < PageNum n++ )找时间物理块
    {
    temp timepg[n]
    if( temp > max )
    {
    max temp
    maxvalue pg[n]
    maxindex n
    }
    }
    Systemoutprintln( max + max )
    Systemoutprintln( maxindex + maxindex )
    pg[maxindex] num[i]
    timepg[maxindex] 1
    for(int j 0 j < PageNum j++)次数存储起
    {
    store[timer][j+1] pg[j]
    }
    store[timer][0] maxindex+1
    timer++
    }
    }
    测试查结果
    for( int i 0 i < PageNum+1 i++)se shi
    {
    for( int j 0 j < numLength j++ )
    {
    Systemoutprint(store[j][i] + )
    }
    Systemoutprintln()
    }
    }

    public int[][] getStore()
    {
    thiscaculate()
    return store
    }

    }


    2 第二
    LRUControljava

    public class LRUControl {
    private int[] num {70120304230321201701}参构造函数
    private int[] num new int[50]参构造函数
    private int numLength
    private int PageNum
    private Page[] pg new Page[10]
    public int[][] store
    public int[][] temp1


    LRUControl()
    {
    PageNum 3
    numLength numlength
    store new int[numLength][PageNum]

    for( int i 0 i {
    pg[i] new Page()
    if( thispg[i] null )
    {
    thispg[i]setValue(1)
    thispg[i]setTime(0)
    }
    else
    {
    Systemoutprintln( 象创建失败 +\\r\\n)
    }
    }
    }

    LRUControl( int nump int[] n int nlength )参数:1物理块数 2页面序列号 3页面序列号数组长度 meiyong
    {
    thisPageNum nump
    numLength nlength
    for(int j 0 j < nlength j++)
    {
    num[j] n[j]
    }
    store new int[numLength][PageNum+1]gai dong
    temp1 new int[numLength][PageNum+1]

    for( int i 0 i {
    pg[i] new Page()
    if( thispg[i] null )
    {
    thispg[i]setValue(1)
    thispg[i]setTime(0)
    }
    else
    {
    Systemoutprintln( 象创建失败 +\\r\\n)
    }
    }


    }

    private boolean checkInPage( Page[] p int plength int keynum )
    {
    for( int jj 0 jj < plength jj++)
    {
    p[jj]setTime( p[jj]getTime()+1 )
    }

    for(int j 0 j < plength j++)
    {
    if( keynum p[j]getValue() )
    {
    return true
    }
    }
    return false
    }

    void caculate()
    {
    int timer 0
    前PageNum先物理快装满
    for( int i 0 i < PageNum i++ )
    {
    pg[i]setValue( num[i] )
    pg[i]setTime( 1 )
    for( int j 0 j < i j++)
    {
    pg[j]setTime( pg[j]getTime()+1 )
    }
    for(int j 0 j < PageNum j++)
    {
    store[timer][j] pg[j]getValue()
    }
    timer++
    }
    for( int i 0 i < PageNum i++)
    {
    store[i][PageNum] 0
    }
    num数组面页面检查否前面出现置该页框时间1没原基础加1
    for( int i PageNum i < numLength i++ )
    {
    if( checkInPage( pg PageNum num[i] ) )果物理框中应位时间置1
    {
    for( int m 0 m < PageNum m++ )num[i]pg[]中相等物理块时间置1
    {
    if( num[i] pg[m]getValue() )
    {
    pg[m]setTime(1)
    break
    }
    }
    for(int j 0 j < PageNum j++)次物理块中数存储起
    {
    store[timer][j] pg[j]getValue()
    }
    store[timer][PageNum] 0
    timer++
    }
    else否找出时间长置换应位时间置1
    {
    int max pg[0]getTime()
    int maxindex 0
    int temp
    for( int n 1 n < PageNum n++ )找时间物理块
    {
    temp pg[n]getTime()
    if( temp > max )
    {
    max temp
    maxindex n
    }
    }
    Systemoutprintln( max + max )
    Systemoutprintln( maxindex + maxindex )
    pg[maxindex]setTime(1)
    pg[maxindex]setValue(num[i])
    for(int j 0 j < PageNum j++)次数存储起
    {
    store[timer][j] pg[j]getValue()
    }
    store[timer][PageNum] maxindex+1
    timer++
    }
    }
    }

    void display()
    {
    for( int i 0 i {
    for(int j 0 j < numLength j++)
    {
    Systemoutprint( store[j][i] + )
    }
    Systemoutprintln()
    }
    }

    private void adjustStore()
    {
    for( int i 1 i {
    for(int j 0 j < numLength j++)
    {
    temp1[j][i] store[j][i1]
    }
    }
    for(int k 0 k < numLength k++)
    {
    temp1[k][0] store[k][PageNum]
    }
    }

    public int[][] getStore()
    {
    adjustStore()
    return temp1
    }

    }

    3 第三第二关联第二page类实现

    Pagejava

    public class Page {
    private int time
    private int value

    public void setTime(int t)
    {
    thistime t
    }

    public void setValue(int v)
    {
    thisvalue v
    }

    public int getTime()
    {
    return thistime
    }

    public int getValue()
    {
    return thisvalue
    }

    Page()
    {
    time 0
    value 0
    }
    }

    4 第四
    MyFramejava

    import javaawtColor
    import javaawtDimension
    import javaawtFileDialog
    import javaawtFont
    import javaawtGraphics
    import javaawtTextArea
    import javaawtToolkit
    import javaawteventActionEvent
    import javaawteventActionListener
    import javaawtimageBufferedImage
    import javaioBufferedReader
    import javaioBufferedWriter
    import javaioFile
    import javaioFileReader
    import javaioFileWriter
    import javaioIOException

    import javaxswingButtonGroup
    import javaxswingJOptionPane
    import javaxswingJPanel
    import javaxswingJButton
    import javaxswingJFrame
    import javaxswingJLabel
    import javaxswingJRadioButton
    import javaxswingJScrollPane
    import javaxswingJSlider
    import javaxswingJTextField
    import javaxswingSwingConstants

    页面置换算法
    public class MyFrame extends JFrame implements ActionListener Runnable{

    int width ToolkitgetDefaultToolkit()getScreenSize()width 取屏幕宽度
    int height ToolkitgetDefaultToolkit()getScreenSize()height 取屏幕高度

    int size10字体

    private JTextField textField1textField2
    private JButton button1button2button3button4button5button6
    private JRadioButton radioButton1 radioButton2
    private ButtonGroup buttongroup
    private JLabel label1 label2 label3 label4 label5 label6
    private JLabel[] label_page new JLabel[20]
    private JLabel label_sign new JLabel(▲)记录运行位置
    private JLabel[][] label_memory new JLabel[50][50]记录存块变化情况
    private JLabel[][] label_memory_LRU new JLabel[50][50]记录存块变化情况
    private JLabel[][] label_memory_FIFO new JLabel[50][50]记录存块变化情况
    private JSlider slider滑动条
    private JPanel panel
    private JScrollPane scrollPane滚动面板

    定义开保存话框
    private FileDialog openDiasaveDia

    private TextArea textArea

    private File file
    private File saveFile
    前点击钮
    private int button_chose 0
    记录动运行前运行位置
    private static int location 0

    Thread thread new Thread(this)

    输入页面号
    private String[] page new String[20]
    private int[] page_int new int[20]
    输入页面号数
    private int page_num 0
    存块数
    private int memory_num 3
    佳置换算法缺页次数
    private int Optimal_lack 0
    记录置换程
    private int[][] process_memory new int[50][50]

    创建LRU象带入参数
    LRUControl lru
    int[][] process_memory_LRU
    LRU置换算法缺页次数
    private int Optimal_lack_LRU 0

    FIFO
    创建象带入参数
    FIFOControl fifo
    创建数组接收数
    int[][] process_memory_FIFO
    FIFO置换算法缺页次数
    private int Optimal_lack_FIFO 0

    private Color[] colors {Colorcyan Colororange ColorgreenColorpink Coloryellow
    Colorcyan Colororange ColorgreenColorpink Coloryellow
    Colorcyan Colororange ColorgreenColorpink Coloryellow
    Colorcyan Colororange ColorgreenColorpink Coloryellow
    }

    MyFrame(){构造函数
    thissetTitle(页面置换算法)
    thissetSize(950 600)
    thissetLocation((width950)2 (height600)2)
    thissetLayout(null)设置布局方式

    label1new JLabel(源文件)
    label1setBounds(30 30 60 30)
    thisadd(label1)

    textField1new JTextField(15)
    textField1setBounds(100 30 300 30)
    thisadd(textField1)

    button1new JButton(开文件)
    button1setBounds(430 30 100 30)
    button1addActionListener(this)
    thisadd(button1)

    radioButton1 new JRadioButton(读入页面 true)
    radioButton2 new JRadioButton(置换情况)
    buttongroup new ButtonGroup()
    buttongroupadd(radioButton1)
    buttongroupadd(radioButton2)
    radioButton1setBounds(600 30 100 30)
    radioButton2setBounds(700 30 100 30)
    thisadd(radioButton1)
    thisadd(radioButton2)



    label2new JLabel(存块数)
    label2setBounds(30 80 60 30)
    thisadd(label2)

    slider new JSlider(JSliderHORIZONTAL1101)
    slidersetBounds(100 80 300 60)
    slidersetValue(3)设置滑动条初始值
    slidersetMajorTickSpacing(9)设置刻度标记间隔
    slidersetMinorTickSpacing(1)设置次刻度标记间隔
    slidersetPaintTicks(true)设置滑块绘制刻度标记显示划分刻度
    slidersetPaintLabels(true)
    slidersetSnapToTicks(true)
    thisadd(slider)

    textArea new TextArea()
    textAreasetBounds(30 160 700 400)
    thisadd(textArea)

    panel new JPanel()
    panelsetBounds(30 160 700 400)
    panelsetBackground(ColorWHITE)
    panelsetPreferredSize(new Dimension(1000800))句代码设置panel首选时保证宽高JScrollPane宽高样面JScrollPane会出现滚动条
    panelsetLayout(null)设置panel布局方式
    thisadd(panel)

    scrollPane new JScrollPane(panel)
    scrollPanesetBackground(ColorWHITE)
    scrollPanesetBounds(30 160 700 400)
    scrollPanesetVerticalScrollBarPolicy(JScrollPaneVERTICAL_SCROLLBAR_AS_NEEDED)
    scrollPanegetHorizontalScrollBar()setValue(0)设置滚动条水位置
    scrollPanegetVerticalScrollBar()setValue(0)设置滚动条竖直位置
    thisadd(scrollPane)
    thisgetContentPane()add(scrollPane)

    label3new JLabel(页面输入序)
    label3setFont(new Font(SerifFontPLAINsize))
    label3setBounds(10 20 70 30)
    paneladd(label3)

    label4new JLabel(佳置换算法)
    label4setFont(new Font(SerifFontPLAINsize))
    label4setBounds(10 90 70 30)
    paneladd(label4)

    label5new JLabel(LRU置换算法)
    label5setFont(new Font(SerifFontPLAINsize))
    label5setBounds(10 190 70 30)
    paneladd(label5)

    label6new JLabel(FIFO置换算法)
    label6setFont(new Font(SerifFontPLAINsize))
    label6setBounds(10 290 70 30)
    paneladd(label6)



    button3new JButton(重置)
    button3setBounds(780 160 100 30)
    button3addActionListener(this)
    thisadd(button3)

    button4new JButton(动运行)
    button4setBounds(780 210 100 30)
    button4addActionListener(this)
    thisadd(button4)

    button5new JButton(单步运行)
    button5setBounds(780 260 100 30)
    button5addActionListener(this)
    thisadd(button5)

    textArea new TextArea()
    textAreasetText(\t缺页率)
    textAreasetBounds(755 310 170 200)
    thisadd(textArea)

    button6new JButton(保存)
    button6setBounds(780 520 100 30)
    button6addActionListener(this)
    thisadd(button6)


    thissetVisible(true)
    thissetResizable(false)

    threadstart()

    for(int i0i<50i++){
    for(int j0j<50j++){
    label_memory[i][j] new JLabel(7)
    label_memory_LRU[i][j] new JLabel()
    label_memory_FIFO[i][j] new JLabel()
    }
    }

    默认模式 FileDialogLOAD
    openDia new FileDialog(this开源文件FileDialogLOAD)
    saveDia new FileDialog(this保存页面置换结果FileDialogSAVE)

    }

    清空面板
    public void removePanel(){
    panelremoveAll()清空面板
    paneladd(label3)
    paneladd(label4)
    paneladd(label5)
    paneladd(label6)
    panelrepaint()刷新面板
    }


    public void actionPerformed(ActionEvent e){

    char ch
    String str

    int page2[] {70120304230321201701}
    int page_num 20
    int memory_num 3
    Optimal(page2 page_num memory_num process_memory)

    if(egetSource()button1){开源文件

    removePanel()清空面板

    openDiasetVisible(true)
    String dirPath openDiagetDirectory()获取文件路径
    String fileName openDiagetFile()获取文件名称
    Systemoutprintln(dirPath ++++ fileName)
    textField1setText(dirPath + fileName)

    果开路径 目录空 返回空
    if(dirPath null || fileName null)
    return

    textAreasetText()清空文

    file new File(dirPathfileName)

    try {
    BufferedReader bufr new BufferedReader(new FileReader(file))
    String line null

    int n 0
    while( (line bufrreadLine()) null){
    输入页面号保存page数组中
    for(int i0i ch linecharAt(i)
    if(ch' '){
    str str + ch

    if(ilinelength()1){获取字符
    page[n] str
    }

    }else{
    if(strequals()){
    page[n] IntegerparseInt(str)
    page[n] str
    n++
    str
    }
    }
    if(n>19) break
    }
    if(n>19) break
    }

    bufrclose()

    page_num n
    Systemoutprintln(页面数+page_num)

    for(int k0k textAreaappend(page[k] + )
    if(page[k]equals()){

    label_page[k] new JLabel(page[k])
    label_page[k]setFont(new Font(SerifFontBOLD12))
    label_page[k]setBounds(100+40*k 20 40 20)
    label_page[k]setOpaque(true)设置透明显示出背景颜色
    label_page[k]setBackground(colors[k])
    label_page[k]setHorizontalAlignment(SwingConstantsCENTER)容居中
    paneladd(label_page[k])
    }
    }
    panelrepaint()刷新面板

    文件中读入页面号信息转化整形
    for(int i0i try{
    page_int[i] IntegerparseInt(page[i])
    }catch(NumberFormatException e1){
    e1printStackTrace()
    JOptionPaneshowMessageDialog(this 什鬼法正确读取源文件信息~)
    page_num 0
    break
    }
    }

    获取存块数
    memory_num slidergetValue()
    Systemoutprintln(存块数+memory_num)

    佳置换算法
    Optimal(page_int page_num memory_num process_memory)

    } catch (IOException ex) {

    throw new RuntimeException(文件读取失败)
    }

    }else if(egetSource()button3){重置

    removePanel()清空面板
    for(int k0k paneladd(label_page[k])加入读入页面信息
    }
    panelrepaint()刷新面板

    location0

    }else if(egetSource()button4){动运行
    button_chose 4

    获取存块数
    memory_num slidergetValue()
    佳置换算法
    Optimal(page_int page_num memory_num process_memory)

    LRU
    lru new LRUControl( memory_num page_int page_num)
    调象计算函数
    lrucaculate()
    传出二维数组
    process_memory_LRU new int[page_num][memory_num+1]
    调象返回参数方法
    process_memory_LRU lrugetStore()
    Systemoutprintln(LRU)
    for(int i0i for(int j0j Systemoutprint(process_memory_LRU[j][i]+ )
    }
    Systemoutprintln()
    }

    FIFO
    fifo new FIFOControl( memory_num page_int page_num)
    process_memory_FIFO new int[page_num][memory_num+1]
    process_memory_FIFO fifogetStore()
    Systemoutprintln(FIFO)
    for(int i0i for(int j0j Systemoutprint(process_memory_FIFO[j][i]+ )
    }
    Systemoutprintln()
    }


    if(page_num0){
    JOptionPaneshowMessageDialog(this 先开源文件哦~)}
    else{

    removePanel()清空面板
    for(int k0k paneladd(label_page[k])加入读入页面信息
    }
    panelrepaint()刷新面板

    new Thread(new Runnable() {

    public void run() {
    button4setEnabled(false)动运行钮设置点击防止次点击造成显示混乱
    button5setEnabled(false)

    根存块少动态调整显示标签位置(改变Y轴起始值)
    int frist_y 0
    if(memory_num>4){
    frist_y memory_num 4
    label5setBounds(10 190 + frist_y*20 70 30)
    label6setBounds(10 290 + frist_y*20*2 70 30)
    }else{
    label5setBounds(10 190 70 30)
    label6setBounds(10 290 70 30)
    }

    scrollPanegetHorizontalScrollBar()setValue(0)设置滚动条水位置


    Optimal_lack 0佳置换缺页数置零
    Optimal_lack_LRU 0LRU缺页数置零
    Optimal_lack_FIFO 0FIFO缺页数置零
    绘制页面置换情况
    for(int k0k label_signsetBounds(100+40*k 40 40 20)
    label_signsetHorizontalAlignment(SwingConstantsCENTER)容居中
    paneladd(label_sign)

    佳置换算法
    for(int j1j if(process_memory[j][k]1){存块空
    label_memory[j][k]setText()
    }else{
    label_memory[j][k]setText(process_memory[j][k]+)process_memory[k][0]+
    }
    label_memory[j][k]setBounds(105+40*k 70+20*j 30 20)
    label_memory[j][k]setHorizontalAlignment(SwingConstantsCENTER)容居中
    label_memory[j][k]setOpaque(true)设置透明显示出背景颜色
    if(process_memory[0][k]0 && jprocess_memory[0][k]){发生置换前存块发生置换存块
    label_memory[j][k]setBackground(ColorRED)
    Optimal_lack++发生置换缺页数加
    }else{
    label_memory[j][k]setBackground(colors[j])
    }
    paneladd(label_memory[j][k])
    }

    LRU
    for(int j1j Systemoutprintln(process_memory_LRU[k][j])
    if(process_memory_LRU[k][j]1){存块空
    label_memory_LRU[j][k]setText()
    }else{
    label_memory_LRU[j][k]setText(process_memory_LRU[k][j]+)process_memory[k][0]+
    }
    label_memory_LRU[j][k]setBounds(105+40*k (170+frist_y*20) + 20*j 30 20)
    label_memory_LRU[j][k]setHorizontalAlignment(SwingConstantsCENTER)容居中
    label_memory_LRU[j][k]setOpaque(true)设置透明显示出背景颜色
    if(process_memory_LRU[k][0]0 && jprocess_memory_LRU[k][0]){发生置换前存块发生置换存块
    label_memory_LRU[j][k]setBackground(ColorRED)
    Optimal_lack_LRU++发生置换缺页数加
    }else{
    label_memory_LRU[j][k]setBackground(colors[j])
    }
    paneladd(label_memory_LRU[j][k])
    }

    FIFO
    for(int j1j if(process_memory_FIFO[k][j]1){存块空
    label_memory_FIFO[j][k]setText()
    }else{
    label_memory_FIFO[j][k]setText(process_memory_FIFO[k][j]+)process_memory[k][0]+
    }
    label_memory_FIFO[j][k]setBounds(105+40*k (270+frist_y*20*2) + 20*j 30 20)
    label_memory_FIFO[j][k]setHorizontalAlignment(SwingConstantsCENTER)容居中
    label_memory_FIFO[j][k]setOpaque(true)设置透明显示出背景颜色
    if(process_memory_FIFO[k][0]0 && jprocess_memory_FIFO[k][0]){发生置换前存块发生置换存块
    label_memory_FIFO[j][k]setBackground(ColorRED)
    Optimal_lack_FIFO++发生置换缺页数加
    }else{
    label_memory_FIFO[j][k]setBackground(colors[j])
    }
    paneladd(label_memory_FIFO[j][k])
    }

    if(k>13){输出超定范围时滚动条显示输出动态变化
    scrollPanegetHorizontalScrollBar()setValue(40*(k13))设置滚动条水位置
    }

    panelrepaint()刷新面板

    延时
    try {
    Threadsleep(500)
    } catch (InterruptedException e1) {
    e1printStackTrace()
    }

    thissetVisible(true)
    }
    button4setEnabled(true)动运行钮恢复点击
    button5setEnabled(true)

    textAreaappend(\n存块数+memory_num+\n页面数+page_num+\n佳置换算法缺页数+Optimal_lack+\n佳置换算法缺页率+(double)Optimal_lackpage_num+
    \nLRU置换算法缺页数+Optimal_lack_LRU+\nLRU置换算法缺页率+(double)Optimal_lack_LRUpage_num +
    \nFIFO置换算法缺页数+Optimal_lack_FIFO+\nFIFO置换算法缺页率+(double)Optimal_lack_FIFOpage_num + \n)
    }
    })start()
    }

    }else if(egetSource()button5){单步运行

    获取存块数
    memory_num slidergetValue()
    佳置换算法
    Optimal(page_int page_num memory_num process_memory)

    if(page_num0){
    JOptionPaneshowMessageDialog(this 先开源文件哦~)}
    else{
    Systemoutprintln(location)
    if(location0){
    removePanel()清空面板
    for(int k0k paneladd(label_page[k])加入读入页面信息
    }
    panelrepaint()刷新面板

    Optimal_lack 0佳置换缺页数置零
    Optimal_lack_LRU 0LRU缺页数置零
    Optimal_lack_FIFO 0FIFO缺页数置零
    }


    根存块少动态调整显示标签位置(改变Y轴起始值)
    int frist_y 0
    if(memory_num>4){
    frist_y memory_num 4
    label5setBounds(10 190 + frist_y*20 70 30)
    label6setBounds(10 290 + frist_y*20*2 70 30)
    }else{
    label5setBounds(10 190 70 30)
    label6setBounds(10 290 70 30)
    }

    scrollPanegetHorizontalScrollBar()setValue(0)设置滚动条水位置

    绘制页面置换情况
    if(location label_signsetBounds(100+40*location 40 40 20)
    label_signsetHorizontalAlignment(SwingConstantsCENTER)容居中
    paneladd(label_sign)

    佳置换算法
    for(int j1j if(process_memory[j][location]1){存块空
    label_memory[j][location]setText()
    }else{
    label_memory[j][location]setText(process_memory[j][location]+)process_memory[k][0]+
    }
    label_memory[j][location]setBounds(105+40*location 70+20*j 30 20)
    label_memory[j][location]setHorizontalAlignment(SwingConstantsCENTER)容居中
    label_memory[j][location]setOpaque(true)设置透明显示出背景颜色
    if(process_memory[0][location]0 && jprocess_memory[0][location]){发生置换前存块发生置换存块
    label_memory[j][location]setBackground(ColorRED)
    Optimal_lack++发生置换缺页数加
    }else{
    label_memory[j][location]setBackground(colors[j])
    }
    paneladd(label_memory[j][location])
    }


    LRU
    for(int j1j Systemoutprintln(process_memory_LRU[k][j])
    if(process_memory_LRU[location][j]1){存块空
    label_memory_LRU[j][location]setText()
    }else{
    label_memory_LRU[j][location]setText(process_memory_LRU[location][j]+)process_memory[k][0]+
    }
    label_memory_LRU[j][location]setBounds(105+40*location (170+frist_y*20) + 20*j 30 20)
    label_memory_LRU[j][location]setHorizontalAlignment(SwingConstantsCENTER)容居中
    label_memory_LRU[j][location]setOpaque(true)设置透明显示出背景颜色
    if(process_memory_LRU[location][0]0 && jprocess_memory_LRU[location][0]){发生置换前存块发生置换存块
    label_memory_LRU[j][location]setBackground(ColorRED)
    Optimal_lack_LRU++发生置换缺页数加
    }else{
    label_memory_LRU[j][location]setBackground(colors[j])
    }
    paneladd(label_memory_LRU[j][location])
    }

    FIFO
    for(int j1j Systemoutprintln(process_memory_LRU[k][j])
    if(process_memory_FIFO[location][j]1){存块空
    label_memory_FIFO[j][location]setText()
    }else{
    label_memory_FIFO[j][location]setText(process_memory_FIFO[location][j]+)process_memory[k][0]+
    }
    label_memory_FIFO[j][location]setBounds(105+40*location (270+frist_y*20*2) + 20*j 30 20)
    label_memory_FIFO[j][location]setHorizontalAlignment(SwingConstantsCENTER)容居中
    label_memory_FIFO[j][location]setOpaque(true)设置透明显示出背景颜色
    if(process_memory_FIFO[location][0]0 && jprocess_memory_FIFO[location][0]){发生置换前存块发生置换存块
    label_memory_FIFO[j][location]setBackground(ColorRED)
    Optimal_lack_FIFO++发生置换缺页数加
    }else{
    label_memory_FIFO[j][location]setBackground(colors[j])
    }
    paneladd(label_memory_FIFO[j][location])
    }

    if(location>13){输出超定范围时滚动条显示输出动态变化
    scrollPanegetHorizontalScrollBar()setValue(40*(location13))设置滚动条水位置
    }

    panelrepaint()刷新面板
    location++

    }else{
    textAreaappend(\n存块数+memory_num+\n页面数+page_num+\n佳置换算法缺页数+Optimal_lack+\n佳置换算法缺页率+(double)Optimal_lackpage_num+
    \nLRU置换算法缺页数+Optimal_lack_LRU+\nLRU置换算法缺页率+(double)Optimal_lack_LRUpage_num +
    \nFIFO置换算法缺页数+Optimal_lack_FIFO+\nFIFO置换算法缺页率+(double)Optimal_lack_FIFOpage_num + \n)
    location 0
    }

    }

    }else if(egetSource()button6){保存

    if(saveFile null)文件存情况 创建文件
    {
    saveDiasetVisible(true)
    String dirPath saveDiagetDirectory()
    String fileName saveDiagetFile()

    if(dirPath null || fileName null)
    return
    saveFile new File(dirPathfileName)
    }

    try
    {
    BufferedWriter bufw new BufferedWriter(new FileWriter(saveFile))

    String text

    for(int i0i for(int j0j text text + process_memory[i][j] +
    }
    text text + *\n
    }

    bufwwrite(text)

    bufwclose()
    }
    catch (IOException ex)
    {
    throw new RuntimeException(文件保存失败)
    }

    }
    }


    public static void main(String args[]) {

    MyFrame landnew MyFrame()

    }


    public void run(){
    死循环
    while(true){
    if(button_chose4){

    for(int k0k<20k++){
    label_signsetBounds(100+40*k 40 40 20)
    label_signsetHorizontalAlignment(SwingConstantsCENTER)容居中
    paneladd(label_sign)

    for(int j0j<3j++){
    label_memory[k][0] new JLabel(7)process_memory[k][0]+
    label_memory[k][0]setBounds(100+40*k 80+20*0 40 20)
    label_memory[k][0]setHorizontalAlignment(SwingConstantsCENTER)容居中
    paneladd(label_memory[k][0])
    }

    延时
    try {
    Threadsleep(500)
    } catch (InterruptedException e1) {
    e1printStackTrace()
    }
    }
    button_chose 0

    }else {

    }

    }
    }


    ***************************************佳置换算法***************************************************
    存块结构体
    class Memory{
    int page 1页面号
    int next 0该页面距次访问时间
    }

    判断页面否已存中
    boolean isMemory(int page Memory memory[] int memory_num){参数(前访问页面号存块数组存块数)
    boolean isTrue false

    for(int i0i if(page memory[i]page)
    isTrue true
    }
    return isTrue
    }

    判断存中否空位
    int isNull(Memory memory[] int memory_num){参数(存块数组存块数)
    int isNull 1

    for(int i0i if(memory[i]page 1){
    isNull i
    break
    }
    }
    return isNull
    }

    页面距次访问时间
    int nextAccess(int page_now int page[] int page_num int now){参数(前访问页面号访问页面数组访问页面总数前访问页面序数)
    int access 0

    for(int inow+1i if(page_now page[i]){
    access inow
    break
    }
    if(i (page_num1)){页面访问
    access 99
    }
    }

    return access
    }

    佳置换算法
    int Optimal(int page[] int page_num int memory_num int process[][]){参数(访问页面数组访问页面总数存块数)

    int max 未长时间访问页面距次访问时间
    int max_page 未长时间访问页面号
    int memory_null 存中空位号(没空位时1)
    int lack 0 记录缺页次数
    int[][] process new int[50][50]记录置换程

    Memory[] memory new Memory[10] 创建存

    记录置换程数组初始化
    for(int a0a for(int b0b process[a][b] 1
    }
    }

    存块初始化
    for(int m0m memory[m] new Memory()
    memory[m]page 1
    memory[m]next 0
    }

    for(int i0i Systemoutprintln(\n读取+page[i])
    if(isMemory(page[i] memory memory_num)){页面已存中
    Systemoutprintln(页面已存中)
    记录
    process[0][i] 0没置换
    for(int n1n process[n][i] process[n][i1]
    }

    }else{ 页面存中

    memory_null isNull(memory memory_num)获取存中空位号(没空位时1)

    if(memory_null1){ [存中没空位]
    获取存块中页面距次访问时间
    for(int j0j memory[j]next nextAccess(memory[j]page page page_num i)
    }
    输出存块中页面距次访问时间
    Systemoutprint(next)
    for(int y0y Systemoutprint(memory[y]next+ )
    }
    Systemoutprintln()

    获取未长时间访问页面号
    max memory[0]next
    max_page 0
    for(int j0j if(memory[j]next>max){
    max memory[j]next
    max_page j
    }
    }
    未长时间访问页面号置换新页面
    Systemoutprintln(置换+memory[max_page]page+>+page[i])
    memory[max_page]page page[i]置换

    lack++更新缺页次数

    记录
    process[0][i] max_page+1发生置换
    process[max_page+1][i] page[i]
    for(int n1n if(nmax_page+1){
    process[n][i] process[n][i1]
    }
    }

    }else { [存中空位]
    Systemoutprintln(存中空位+memory_null)
    memory[memory_null]page page[i]
    新页面放入存块空位中
    for(int x0x Systemoutprint(memory[x]page+ )
    }
    Systemoutprintln()

    记录
    process[0][i] 0没置换
    process[memory_null+1][i] page[i]
    for(int n1n if(nmemory_null+1){
    if(i>0){
    process[n][i] process[n][i1]
    }else{
    process[n][i] 1
    }
    }
    }
    }

    }
    }

    Systemoutprintln(\n缺页数+lack)
    Systemoutprintln(缺页率+(double)lackpage_num)

    Systemoutprintln(佳页面置换算法置换表)
    for(int a0a for(int b0b Systemoutprint(process[a][b]+ )
    }
    Systemoutprintln()
    }

    return 0
    }
    *************************************************************************************************


    }

    文档香网(httpswwwxiangdangnet)户传

    《香当网》用户分享的内容,不代表《香当网》观点或立场,请自行判断内容的真实性和可靠性!
    该内容是文档的文本内容,更好的格式请下载文档

    下载文档到电脑,查找使用更方便

    文档的实际排版效果,会与网站的显示效果略有不同!!

    需要 2 香币 [ 分享文档获得香币 ]

    下载文档

    相关文档

    操作系统 七次实验报告 常用页面置换算法模拟实验

    操作系统课程第七次实验报告姓名学号系计算机任课教师指导教师评阅教师实验地点 综合楼B102 实验时间2012-9-26实验课表现出勤和个人表现Q1(15+15(组长评分)=30分)得...

    3年前   
    734    0

    页面置换算法实验(内含完整代码)

    实验二 存储管理 一、 实验目的 通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟存储技术的特 点,掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程, 并...

    6个月前   
    155    0

    计算机操作系统实验三页面置换算法模拟实验

    计算机工程学院实验报告书课程名:《 操作系统原理A 》 题 目: 虚拟存储器管理 页面置换算法模拟实验...

    3年前   
    625    0

    操作系统课程设计银行家算法报告

    《操作系统--银行家算法》课程设计报告姓 名: 学 号: 班 级:计科班 ...

    3年前   
    613    0

    《操作系统 银行家算法》课程设计报告

    《操作系统--银行家算法》课程设计报告姓 名: 学 号: 班 级: 计科班 ...

    3年前   
    801    0

    银行家算法《操作系统》课程设计报告

    《操作系统》课程设计报告课题: 银行家算法 专业计算机科学与技术学生姓名班级计算机学号指导教师信息工程...

    3年前   
    682    0

    进程调度算法的实现计算机操作系统课程设计

    题目2 进程调度算法的实现2.1 题目的主要研究内容及预期达到的目标(1)设计进程控制块; (2)设计多个进程队列; (3)设计多个进程(≥20); (4)动态生成时间片、执行时间和优先级,...

    3年前   
    574    0

    操作系统课程设计银行家算法的模拟实现

    操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期信息工程学院题目: 银行家算法的模拟实现 一、设计目的本课程设计是学习完“操作系统原理”课程后进...

    3年前   
    665    0

    操作系统课程设计磁盘调度算法

    操作系统课程设计磁盘调度算法目 录1 课程设计目的及要求……………………………………………………12 相关知识…………………………………………………………………13 ...

    3年前   
    532    0

    操作系统课程设计磁盘调度算法

    《计算操作系统》课程设计报告 姓名: ...

    3年前   
    449    0

    操作系统课程设计编程序模拟银行家算法

    课程设计报告书 课程名称: 操作系统原理 题 目: 编程序模拟银行家算法 系 名: 信息工程系 专业班级: ...

    3年前   
    707    0

    操作系统实验报告C语言实现银行家算法

    实 验 报 告题 目名 称C语言实现银行家算法院 系信息科学与工程学院班 级完成时间指导老师本次实验成绩组长联系电话邮件地址组员(姓名,学号)主要任务程序算法的编写、实现、运行调...

    3年前   
    458    0

    驱动程序实验报告操作系统课程设计报告

    操作系统课程设计报告班级: 计科 姓名: 学号: 老师: 时间:2012年X月X日一、设计目的操作...

    1年前   
    289    0

    操作系统实验四主存空间的分配与回收首次适应算法和循环首次适应算法

    实验报告【实验名称】 首次适应算法和循环首次适应算法 【实验目的】理解在连续分区动态的存储管理方式下,如何实现主存空间的分配与回收。【实验原理】首次适应(first fit,FF...

    3年前   
    1032    0

    数据结构和算法课程设计题目

    XX大学课程设计课程名称: 数 据 结 构 与 算 法院(部)名 称: 信息与计算科学学院组长姓名学号 同组人员姓名指导教师姓名: 设 计 时 间: 2010.6.7-...

    10个月前   
    362    0

    操作系统课程设计报告树型目录文件系统

    操作系统课程设计报告题目:树型目录文件系统 学 院 计算机学院 专 业 网络工程 年级班别 班 学 ...

    3年前   
    531    0

    哲学家进餐问题操作系统课程设计报告

    XX学院 《操作系统》课程设计报告题 目: 哲学家进餐问题 班 级: 学 号: ...

    2年前   
    715    0

    数据结构课程设计报告最小生成树Kruskal算法

    计算机科学与技术系课程设计报告 2014-2015学年第二学期课程数据结构课程设计名称Kruskal算法求最小生成树学生姓名 学号 专业班级 软件工程指导教师 2014年X月题目:设计...

    1年前   
    196    0

    合工大计算方法试验报告

    《计算方法》试验报告 班级: 学号: 姓名:实验一、牛顿下山法1 实验目的(1) 熟悉非线性方程求根简单迭代法,牛顿迭代及牛顿下山法(2) 能编程实现简单迭代法...

    3年前   
    630    0

    操作系统实验三磁盘调度算法的实现

    XX大学计算机与通信工程学院实验报告2013 至 2014 学年 第 一 学期课程名称操作系统学号 学生姓名 年级 专业 教学班号 实验地点 实验时间 2013年 月 日 ...

    3年前   
    472    0

    文档贡献者

    文***品

    贡献于2021-06-28

    下载需要 2 香币 [香币充值 ]
    亲,您也可以通过 分享原创文档 来获得香币奖励!
    下载文档

    该用户的其他文档