时钟置换算法CLOCK
页面置换算法(FIFO,LRU,最佳,Clock)
#include<iostream>using namespace std;void Print(int bc[],int blockCount){for(int i=0;i<blockCount;i++){cout<<bc[i]<<" ";}cout<<endl;}bool Travel(int bc[],int blockCount,int x){bool is_found=false;int i;for(i=0;i<blockCount;i++){if(bc[i]==x){is_found=true;break;}}return is_found;}void FIFO(int pc[],int bc[],int pageCount,int blockCount) {cout<<"0：FIFO置换算法"<<endl;int i;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int p=0;for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{if(p==blockCount){p=0;}bc[p]=pc[i];p++;}noPage++;cout<<"物理快情况：";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;}}int FoundMaxNum(int a[],int n){int k,j;k=a[0];j=0;for (int i=0;i<n;i++){if(a[i]>=k){k=a[i];j=i;}}return j;}void LRU(int pc[],int bc[],int pageCount,int blockCount){cout<<"1：LRU置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j,m;int *bc1=new int[blockCount];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];for(int p=0;p<=i;p++){bc1[p]++;}}else{for(j=0;j<blockCount;j++){bc1[j]++;}int k=FoundMaxNum(bc1,blockCount);bc[k]=pc[i];bc1[k]=1;}noPage++;cout<<"物理快情况：";Print(bc,blockCount);}else if(Travel(bc,blockCount,pc[i])){if(i<blockCount){for(j=0;j<=i;j++){bc1[j]++;}for(m=0;m<=i;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}else{for(j=0;j<blockCount;j++){bc1[j]++;}for(m=0;m<blockCount;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;delete bc1;}}void Optiomal(int pc[],int bc[],int pageCount,int blockCount){cout<<"2：最佳置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j,k;for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{int max=0;int blockIndex;;for(j=0;j<blockCount;j++){for(k=i;k<pageCount;k++){if(bc[j]==pc[k]){break;}}if(k>=max){max=k;blockIndex=j;}}bc[blockIndex]=pc[i];}noPage++;cout<<"物理快情况：";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;}}void NRU(int pc[],int bc[],int pageCount,int blockCount){cout<<"3：Clock置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j;int *bc1=new int[blockCount];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){for(j=0;j<blockCount;j++){if(bc1[j]==1){bc1[j]=0;}else if(bc1[j]==0){break;}if(j==blockCount-1){j=-1;}}bc[j]=pc[i];bc1[j]=1;noPage++;cout<<"物理快情况：";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;delete bc1;}}int main(){int pageCount,blockCount,i;cout<<"输入页面数"<<endl;cin>>pageCount;int *pc=new int[pageCount];cout<<"输入页面走向"<<endl;for(i=0;i<pageCount;i++){cin>>pc[i];}cout<<"输入物理块数"<<endl;cin>>blockCount;cout<<"0：FIFO置换算法"<<endl;cout<<"1：LRU置换算法"<<endl;cout<<"2：最佳置换算法"<<endl;cout<<"3：Clock置换算法"<<endl;cout<<"按数字选择算法类别："<<endl;int n;while(cin>>n){if(n==0){int *bc=new int[blockCount];FIFO(pc,bc,pageCount,blockCount);delete bc;}else if(n==1){int *bc=new int[blockCount];LRU(pc,bc,pageCount,blockCount);delete bc;}else if(n==2){int *bc=new int[blockCount];Optiomal(pc,bc,pageCount,blockCount);delete bc;}else if(n==3){int *bc=new int[blockCount];for(i=0;i<blockCount;i++){bc[i]=-1;}NRU(pc,bc,pageCount,blockCount);delete bc;}else break;}delete pc;return 0;}。
实验六改进型Clock页面置换算法实现
计算机操作系统综合设计实验六实验名称：改进型Clock页面置换算法实现实验类型：验证型实验实验环境： Visual C++ 6.0指导老师：陈立伟专业班级：姓名：学号:联系电话：实验地点：东六E座4-02实验日期： 2014年12月14日实验报告日期： 2014年12月 14日成绩：__________________________一、实验目的1）理解页面置换相关理论；2）掌握Clock置换算法和改进型Clock置换算法。
二、实验平台windows 7 Visual C++ 6.0三、实验步骤1、实验内容1）设计页面置换相关数据结构；2）给一个进程设计多个（≥10）页面；3）设定为每个进程提供的页面数（≤5）；4）可动态修改页面信息（包括调用标志和修改标志）；5）实现改进型Clock页面置换算法；6）动态给出页面调用序列并进行调度；7）输出置换结果。
2、实验步骤1）输入代码A、打开Visual C++ 6.0；B、新建c++文件，创建basic.h头文件，并且创建clock.cpp；2）进行功能测试并得出正确结果A、编译、运行clock.cpp。
B、输入引用次数，以及页面号。
C、得到页面执行结果，以及缺页率。
3）clock置换函数程序流程图分析clock置换函数的代码，画出如下流程图：四、实验总结通过这次课程设计,加深了对操作系统的认识,了解了操作系统中各种资源分配算法的实现,特别是对虚拟存储,页面置换有了深入的了解,并能够用高级语言进行模拟演示。
对于clock函数的实现，起初根本不知道怎么下笔，但是认真分析了它的运作机制，就逐步清晰了。
通过浏览、阅读有关的资料，学到了很多东西。
一分耕耘，一分收获，这次的课程设计让我受益匪浅。
虽然自己所做的很少也不够完善，但毕竟也是努力的结果。
另外，使我体会最深的是：任何一门知识的掌握，仅靠学习理论知识是远远不够的，要与实际动手操作相结合才能达到功效。
（完整版）Clock及改进Clock置换算法实现
（完整版）Clock及改进Clock置换算法实现操作系统课程设计报告书Clock及改进Clock置换算法实现班级姓名学号指导⽼师2014年3⽉12⽇⽬录⼀、课程设计⽬的 (3)⼆、系统分析与设计 ................... . (3)三、算法流程图： ......... .. (4)四、函数模块: (6)五、系统调试与结果： (7)六、设计⼼得与体会： ............ .. (9)七、源程序代码: (15)⼀、课程设计⽬的操作系统课程设计是为了对学习的操作系统课程更深刻的理解和巩固，对操作系统的整体进⾏⼀个模拟。
通过实践加深对各个部分的管理功能的认识，还能进⼀步分析各个部分之间的联系，最后达到对完整系统的理解。
同时，可以提⾼运⽤操作系统知识解决实际问题的能⼒；锻炼实际的编程能⼒、创新能⼒及团队组织、协作开发软件的能⼒；还能提⾼调查研究、查阅技术⽂献、资料以及编写软件设计⽂档的能⼒。
课程设计是⾃⼰独⽴完成⼀项任务的过程，编程过程中要充分调动个⼈的积极性，提⾼⾃⾝解决实际问题的能⼒，发现⾃⾝的编程错误习惯，提⾼编写程序的质量。
同时，也为以后深⼊层次的学习及研究打基础。
编程中少不了难题，遇到难题时需要的是⽤程序员的思维⽅式去考虑问题解决问题，还需要很⼤的精⼒和耐⼼，对于我们来说都是磨练和提⾼。
⼆、系统分析与设计在采⽤请求分页机制的操作系统中，当运⾏⼀个程序的时候，若要访问的页⾯不在内存中⽽需要把它们调⼊内存，但此时内存已⽆空闲空间，为了保证该进程能正常运⾏，需选择内存中暂时不⽤的页⾯调出到磁盘交换区。
选择调出哪个页⾯，由页⾯算法决定。
页⾯置换算法的好坏，直接影响系统的性能，所以⼀个好的页⾯置换算法，应尽可能选择调出较长时间内不会再访问的页⾯，以保证较低的缺页率。
2.1 Clock页⾯置换原理描述Clock算法的思想：当某⼀页⾸次装⼊内存中时，则将该页框的使⽤位设置为1；当该页随后被访问到时（在访问产⽣缺页中断之后），它的使⽤位也会被设置为1。
时钟置换算法CLOCK(答案参考)
时钟置换算法（CLOCK）例题：一个作业的物理块数为3，此作业的页面走向为：内存及控制信息输入串指针移动情况及帧替换信息是否缺页？内存访问位指针3内存中没有3，需要找到一个帧放入3，指针所指的位置恰好有访问位为0的，于是就淘汰这个帧，指针下移√0←内存访问位指针4内存中没有4，需要找到一个帧放入4，指针所指的位置恰好有访问位为0的，于是就淘汰这个帧，指针下移√310←内存访问位指针2内存中没有2，需要找到一个帧放入2，指针所指的位置恰好有访问位为0的，于是就淘汰这个帧，指针下移√31410←内存访问位指针6内存中没有6，需要找到一个帧放入6，指针所指的位置的访问位为1，将其变成0，再下移√31←4121内存访问位指针指针所指的位置的访问位仍为1，将其变成0，再下移3041←21内存访问位指针指针所指的位置的访问位仍为1，将其变成0，再下移（回到开头）304021←内存访问位指针指针所指的位置恰好有访问位为0的，于是就淘汰这个帧，指针下移30←4020内存访问位指针4内存中有4，于是4所在帧的访问位变为1，指针下移×6140←20内存访问位指针3内存中没有3，需要找到一个帧放入3，指针所指的位置恰好有访问位为0的，于是就淘汰这个帧，指针下移√614120←内存访问位指针7内存中没有7，需要找到一个帧放入7，指针所指的位置的访问位为1，将其变成0，再下移√61←41 31内存访问位指针指针所指的位置的访问位仍为1，将其变成0，再下移6041←31内存访问位指针指针所指的位置的访问位仍为1，将其变成0，再下移（回到开头）604031←内存访问位指针指针所指的位置恰好有访问位为0的，于是就淘汰这个帧，指针下移60←4030内存访问位指针4内存中有4，于是4所在帧的访问位变为1，指针下移×7140←30内存访问位指针3内存中有3，于是3所在帧的访问位变为1，指针下移（回到开头）×71 41。
clock替换算法
Clock 替换算法（也称为时钟置换算法）是一种用于虚拟内存管理的页面替换策略。
它的目的是在需要为新页面在内存中分配空间时选择合适的页面进行替换。
Clock 算法是LRU（最近最少使用）算法的一种近似实现，通常用于操作系统的页面置换。
Clock 算法的命名来源于它的数据结构类似于一个时钟，页面按顺序排列成一个圆形队列。
Clock 算法采用以下方法进行操作：
1. 它维护一个指针，指向有序队列中的一个页面，该指针初次指向第一个页面。
2. 当需要替换某个页面时，算法检查当前指针所指向的页面。
3. 如果该页面的访问位（accessed bit）为 0，则选择该页面进行替换。
4. 如果访问位为 1，则将访问位设置为 0，并将指针移动到下一个页面。
5. 重复步骤 2-4，直到找到一个访问位为 0 的页面。
在这个过程中，访问位表示页面自上次访问以来是否被访问过。
如果页面被访问，其访问位将设置为 1；否则，访问位保持为 0。
Clock 算法使用这个信息来尝试近似 LRU 策略——即选择最近最少使用的页面进行替换。
通过这种方法，Clock 算法可以在较低的开销下实现合适的页面替换。
值得注意的是，虽然 Clock 算法尝试近似 LRU 策略，但它并不能完全等同于 LRU。
Clock 算法可能会产生较差的近似结果，尤其是在页面访问模式较为复杂时。
然而，由于其相对较低的实现成本，Clock 算法在许多操作系统中被用作默认的页面替换策略。
操作系统页面置换算法（C++实现）
操作系统页⾯置换算法（C++实现）1. 最佳（Optimal）置换算法1.1 算法原理 其选择淘汰的页⾯将是以后永不使⽤的，或许是在最长时间内不再被访问的页⾯。
采⽤最佳置换算法通常可以保证获得最低的缺页率。
但由于⼈们⽬前还⽆法预知，⼀个进程在内存的若⼲个界⾯中，哪⼀个页⾯是未来最长时间内不再被访问的，因⽽该算法是⽆法实现的，但可以利⽤它来评价其他算法。
现举例如下： 最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串： 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时，先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时，产⽣缺页中断，根据最佳置换算法，选择第18次访问才需调⼊的页⾯7予以淘汰。
然后，访问页⾯0时，因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推，如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到，发⽣缺页中断的次数为9，页⾯置换的次数为6。
访问页⾯70120304230321201701177722222720000400031133311缺页否√ √√√√√√√√1.2 实现代码函数1void Optimal(vector<int> PageOrder, vector<vector<int> > &Simulate, int &PageNum,int &LackNum, int m, int n){2 vector<bool> found(n,false); // 记录页⾯中是否存在3 vector<int> lump; // 物理块45for(int i = 0; i < n; found[PageOrder[i]] = true, i ++){6//物理块中不存在7if( !found[PageOrder[i]] ){8// 物理块未满时9if(lump.size() < m){10 lump.push_back(PageOrder[i]);11 }12// 物理块满需要置换13else{14int temp, max = 0;15for(int j = 0; j < lump.size(); j ++){16int count = i;17for(; count < n + 1; count ++)18if(PageOrder[count] == lump[j]) break;19if(count > max){20 max = count;temp = j; // 记录当前最远页⾯序号21 }22 }23 found[lump[temp]] = false;24 lump[temp] = PageOrder[i];25 }26for(int j = 0; j < lump.size(); j ++)27 Simulate[i].push_back(lump[j]);28 LackNum ++; //访问页⾯失败29 }30//物理块中存在31else32 PageNum ++; //访问页⾯成功33 }34 }2. 先进先出（FIFO）置换算法2.1 算法原理 是最简单的页⾯置换算法。
操作系统原理-时钟(CLOCK)置换算法
时钟(CLOCK)置换算法LRU算法的性能接近于OPT,但是实现起来比较困难，且开销大；FIFO算法实现简单，但性能差。
所以操作系统的设计者尝试了很多算法，试图用比较小的开销接近LRU的性能，这类算法都是CLOCK算法的变体。
简单的CLOCK算法是给每一帧关联一个附加位，称为使用位。
当某一页首次装入主存时，该帧的使用位设置为1;当该页随后再被访问到时，它的使用位也被置为1。
对于页替换算法，用于替换的候选帧集合看做一个循环缓冲区，并且有一个指针与之相关联。
当某一页被替换时，该指针被设置成指向缓冲区中的下一帧。
当需要替换一页时，操作系统扫描缓冲区，以查找使用位被置为0的一帧。
每当遇到一个使用位为1的帧时，操作系统就将该位重新置为0；如果在这个过程开始时，缓冲区中所有帧的使用位均为0，则选择遇到的第一个帧替换；如果所有帧的使用位均为1,则指针在缓冲区中完整地循环一周，把所有使用位都置为0，并且停留在最初的位置上，替换该帧中的页。
由于该算法循环地检查各页面的情况，故称为CLOCK算法，又称为最近未用(Not Recently Used, NRU)算法。
CLOCK算法的性能比较接近LRU，而通过增加使用的位数目，可以使得CLOCK算法更加高效。
在使用位的基础上再增加一个修改位，则得到改进型的CLOCK置换算法。
这样，每一帧都处于以下四种情况之一：1.最近未被访问，也未被修改(u=0, m=0)。
2.最近被访问，但未被修改(u=1, m=0)。
3.最近未被访问，但被修改(u=0, m=1)。
4.最近被访问，被修改(u=1, m=1)。
算法执行如下操作步骤：1.从指针的当前位置开始，扫描帧缓冲区。
在这次扫描过程中，对使用位不做任何修改。
选择遇到的第一个帧(u=0, m=0)用于替换。
2.如果第1)步失败，则重新扫描，查找(u=0, m=1)的帧。
选择遇到的第一个这样的帧用于替换。
在这个扫描过程中，对每个跳过的帧，把它的使用位设置成0。
Clock-及改进-Clock置换算法实现知识分享
C l o c k-及改进-C l o c k置换算法实现操作系统课程设计报告学院：学生姓名:＿＿学号:题目：Clock 及改进 Clock置换算法实现指导教师:一、课程设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
●进一步巩固和复习操作系统的基础知识。
●培养学生结构化程序、模块化程序设计的方法和能力。
●提高学生调试程序的技巧和软件设计的能力。
●提高学生分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。
二、课程设计内容与要求：模拟实现Clock及改进Clock置换算法，程序应按照Clock置换算法及改进Clock置换算法模拟实现页面的置换。
1．不同的功能使用不同的函数实现（模块化），对每个函数的功能和调用接口要注释清楚。
对程序其它部分也进行必要的注释。
2．对系统进行功能模块分析、画出总流程图和各模块流程图。
3．用户界面要求使用方便、简洁明了、美观大方、格式统一。
所有功能可以反复使用，最好使用菜单。
4．通过命令行相应选项能直接进入某个相应菜单选项的功能模块。
5．所有程序需调试通过三、算法及关键数据结构设计(1)Clock置换算法：当采用简单Clock算法是只需为每页设置一位访问位，再将内存中的所用页面都通过链接指针链接成一个循环队列。
当某页被访问时，其访问位被置1。
置换算法在选择一页淘汰时，只需检查页的访问位。
如果是0，就选择该页换出；若为1，则重新将他置0,暂不换出，而给该页第二次驻留内存的机会,在按照FIFO 算法检查下一个页面。
当检查到队列中的最后一个页面是，若其访问位仍为1，则再返回到队首去检查第一个页面。
（2）算法流程图（3）改进型Clock置换算法在将一个页面换出时，如果该页已被修改过，便须将该页重新写回到磁盘上；但如果该页未被修改过，则不必将它拷回磁盘。
在改进型Clock算法中，除须考虑页面的使用情况外，还须在增加一个因素，即置换代价，这样页面换出时，既要是未使用过的页面，又要是未被修改过的页面。
操作系统实验报告(clock算法)
实验四页面置换算法一、实验目的本实验主要对操作系统中请求分页式内存管理及其应用的一些关键算法进行模拟。
学生通过设计与实现Clock算法，能够加强对相应理论的理解，并对了解操作系统内部的基本处理原理与过程也有很多益处。
二、实验要求基本要求：描述Clock算法的基本原理、必要的数据结构、算法执行流程图、编码实现。
1）初始化：输入作业可占用的总页框数，初始化置空。
2）输入请求序列：输入一个作业页号访问请求序列，依次占用相应页框，直至全部占用；3）Clock算法：当页框全部占用后，对于后续新的页号访问请求，执行Clock算法，淘汰1个页面后装入新的页号。
4）显示当前分配淘汰序列：显示淘汰的页号序列。
描述Clock算法的基本原理、必要的数据结构、算法执行流程图、编码实现。
三、实验内容1)基本原理时钟页面置换算法是把所有的页面都保存在一个类似钟面的环形链表中，一个表针指向最老的页面，如图所示。
当发生缺页中断时，算法首先检查表针指向的页面，如果它的R位是0就淘汰该页面，并把新的页面插入这个位置，然后把表针前移一个位置；如果R位是1就清除R位并把表针前移一个位置，重复这个过程直到找到了一个R位为0的页面为止。
2)算法流程设计主函数流程:STEP1:输入分配的页框数，页面访问次数和要访问的页面号序列STEP2:内存页面初始化。
内存中页面的数据结构为单循环链表，含有页号值yehao和访问位值a。
开始时页号均为-1，访问位为0.STEP3：测试数据。
具体算法是依要访问的页面号，调用find()函数查找是否已经存在于内存中。
若存在，则修改其访问位为1.若不存在，触发缺页中断，调用tihuan()函数。
最后，打印当前内存状态。
如此循环直至测试串都访问完毕。
3)主要函数实现a)Makenode(double)函数：用于初始化一个节点。
b)Find（double）函数：依据输入的页号，查询内存中是否已存在此页面。
若存在返回值1，不存在返回值0.c)Tihuan（double）函数：在发生缺页中断时，时钟指针查找访问位为0的页面进行替换，指针扫过的页面访问位置0，新加入的页面访问位置1。
页面置换算法之Clock算法
页面置换算法之Clock算法1.前言缓冲池是数据库最终的概念，数据库可以将一部分数据页放在内存中形成缓冲池，当需要一个数据页时，首先检查内存中的缓冲池是否有这个页面，如果有则直接命中返回，没有则从磁盘中读取这一页，然后缓存到内存并返回。
但是内存的价值较高，一般来说服务器的内存总是小于磁盘大小的，而且内存不能完全分配给数据库作为缓冲池。
这就意味着数据库基本上无法将所有的数据都缓冲到内存中。
当缓冲池满后，如果还有新的页面要被缓冲到池中，就要设计一种页面置换的算法，将一个旧的页面替换成新的页面。
一般来说我们熟悉的算法有下面几种：下面逐一介绍各种算法。
2. 最佳置换算法如果被替换掉的页是以后再也不会使用的，那么这种算法无疑是最优秀的。
因为不管什么算法，替换掉的页也有可能再次被缓存，替换掉其它的页。
但是这种算法是无法实现的，我们不可能知道哪个页面以后也在不会被使用。
或者我们退一步，将这个算法改成被替换掉的页是以后很长一段时间都不会再次被使用的，那么这种算法无疑也是最优秀的。
但是还是会面对一个无法实现的问题，我们还是不知道哪些页面会在未来多长一段时间内不会被再次访问。
页面无法确认，时间也无法确定。
虽然这种算法无法被实现，但是可以作为一种度量，如果有一种算法其效率最接近OPT，那么这种算法无疑是优秀的算法。
3. 先进先出算法先进先出算法是一种很简单的算法，其基本思想是形成一个队列，最先入队的页面最先被逐出。
我们用示意图来模拟一下FIFO算法：我们的内存假设只能保存4个页面，此时的访问请求按照时间顺序是1->2->3->4->5，那么按照时间顺序，当访问到4号页面时队列正好填满，当要访问5号页面时，会将最先入队的1号页面逐出。
这种算法实现起来很简单，但是从实现上来看，性能和OPT算法差距最大。
因为被替换出去的页面很有可能是最常使用的页面，因此这个算法很少见出现在数据库缓冲池管理中的。
FIFO算法会出现一个叫做Belay异常的现象，就这个现象我们解释如下。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
时钟置换算法（CLOCK）例题：
一个作业的物理块数为3，此作业的页面走向为：3,4,2,6,4,3,7,4,3,6,3,4,8,4,6
内存及控制信息输入串指针移动情况及帧替换信息是否缺页？
内存访
问
位
指针
3
内存中没有3，需要找到一个帧放
入3，
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移
√0←
内存访
问
位
指针
4
内存中没有4，需要找到一个帧放
入4，
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移
√
31
0←
内存访
问
位
指针
2
内存中没有2，需要找到一个帧放
入2，
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移
√
31
41
0←
内存访
问
位
指针
6
内存中没有6，需要找到一个帧放
入6，
指针所指的位置的访问位为1，
将其变成0，再下移
√
31←41
21
内存访
问
位
指针指针所指的位置的访问位仍为1，
将其变成0，再下移
30
41←21
内存访
问
位
指针
指针所指的位置的访问位仍为1，
将其变成0，再下移（回到开头）
30
40
21←
内存访
问
位
指针
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移
30←40
20
内存访
问
位
指针
4
内存中有4，于是4所在帧的访问
位变为1，
指针下移
×
61
40←20
内存访
问
位
指针
3
内存中没有3，需要找到一个帧放
入3，
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移
√
61
41
20←
内存访
问
位
指针
7
内存中没有7，需要找到一个帧放
入7，
指针所指的位置的访问位为1，
将其变成0，再下移
√
61←41
31
内存访
问
位
指针
指针所指的位置的访问位仍为1，
将其变成0，再下移
60
41←31
内存访
问
位
指针
指针所指的位置的访问位仍为1，
将其变成0，再下移（回到开头）
60
40
31←
内存访
问
位
指针
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移
60←40
30
内存访
问
位
指针
4
内存中有4，于是4所在帧的访问
位变为1，
指针下移
×
71
40←30
内存访
问
位
指针
3
内存中有3，于是3所在帧的访问
位变为1，
指针下移（回到开头）
×
71
41
30←
内存访
问
位
指针6
内存中没有6，需要找到一个帧放
入6，
指针所指的位置的访问位为1，
√
71←将其变成0，再下移41
31
内存访
问
位
指针
指针所指的位置的访问位仍为1，
将其变成0，再下移
70
41←31
内存访
问
位
指针
指针所指的位置的访问位仍为1，
将其变成0，再下移（回到开头）
70
40
31←
内存访
问
位
指针
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移
70←40
30
内存访
问
位
指针
3
内存中有3，于是3所在帧的访问
位变为1，
指针下移
×
61
40←30
内存访
问
位
指针
4
内存中有4，于是4所在帧的访问
位变为1，
指针下移
×
61←40
31
内存访
问
位
指针
8
内存中没有8，需要找到一个帧放
入8，
指针所指的位置的访问位为1，
将其变成0，再下移（回到开头）
√
61
41
31←
内存访
问
位
指针
指针所指的位置的访问位仍为1，
将其变成0，再下移
61←41
30
内存访
问
位
指针
指针所指的位置的访问位仍为1，
将其变成0，再下移
60
41←30
内存访
问
位
指针
指针所指的位置恰好有访问位为
0的，
于是就淘汰这个帧，指针下移（回
到开头）
60
40
30←
内存访
问
位
指针
4
内存中有4，于是4所在帧的访问
位变为1，
指针下移
×
60←
40
81
内访指针6内存中有6，于是6所在帧的访问×
存问
位位变为1，指针下移
60
41
81←
内存访
问
位
指针
结束完成缺页8次
61
41←81。