页面置换算法
页面置换算法PPT课件
练习
在一个请求分页系统中，假定系统分配给一个进程的内存 块数为3，进程的页面走向为2，3，2，1，5，2，4，5，3， 2，5，2。试用最近最久未使用置换算法（LRU），请画图 表示访问过程中发生的页面置换过程，并计算缺页次数。 （假定开始时，物理块为空，每次调入页面都作为一次缺 页处理）
第5页/共36页
4.6.3
1. 何时调入页面
第6页/共36页
2. 从何处调入页面 在请求分页系统中的外存分为两部分：用于存放文件的
文件区和用于存放对换页面的对换区。通常，由于对换区是 采用连续分配方式，而事件是采用离散分配方式，故对换区 的磁盘I/O速度比文件区的高。这样，每当发生缺页请求时， 系统应从何处将缺页调入内存，
第11页/共36页
4.7.1
1. 最佳(Optimal) Belady于1966年提出的一种理论上的算法，思想是选择的 被淘汰页面以后将永不使用，或者在最长（未来）时间内 不再被访问。
第12页/共36页
假定系统为某进程分配了三个物理块， 并考虑有以下
7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1
第25页/共36页
4.7.3 Clock置换算法
1. 简单的Clock置换算法 Clock置换算法是LRU算法的近似算法，也称为最近未 用算法。在简单的Clock算法中，为每页设置一访问位， 当被访问则设置为1，未访问为0。
第26页/共36页
1. 简单的Clock置换算法
入口
查寻指 针前进一步 ，指向 下一个 表目
进程运行时， 先将7，0，1三个页面装入内存。 以后， 当进程要访问页面2时， 将会产生缺页中断。此时OS根据 最佳置换算法， 将选择页面7予以淘汰。
LRU页面置换算法实现策略概述
LRU页面置换算法实现策略概述LRU页面置换算法（Least Recently Used）是一种常用的页面置换算法，用于在固定大小的存储中管理页面的使用。
本文将对LRU页面置换算法的实现策略进行概述。
1. 算法背景在计算机系统中，页面置换算法用于管理页面的使用，以充分利用有限的物理内存资源。
其中，LRU算法是一种基于页面访问顺序的置换算法，它假设最近被访问的页面在未来一段时间内仍然可能被频繁使用，因此选择未被使用最久的页面进行置换，以达到优化存储利用率的目的。
2. 实现策略LRU页面置换算法的实现主要涉及两个方面：数据结构和操作流程。
2.1 数据结构在实现LRU算法时，需要使用一个数据结构来维护页面的访问顺序。
常用的数据结构包括链表和哈希表。
- 链表：使用双向链表来维护页面的访问顺序，链表头表示最近被使用的页面，链表尾表示最久未被使用的页面。
- 哈希表：使用哈希表来实现页面的查找，将页面的访问顺序与页面本身相关联。
2.2 操作流程LRU算法的操作流程如下所示：- 当一个页面被访问时，首先在哈希表中查找该页面。
- 若页面不存在于哈希表中，则说明页面为新页面，将其添加到链表头，并更新哈希表。
- 若页面存在于哈希表中，则说明页面已经存在，需要将其从链表中删除，并将其添加到链表头表示最近被使用。
- 若页面数量超过了存储容量，则将链表尾的页面删除，并更新哈希表。
3. 算法示例为便于理解，以下给出一个基于链表和哈希表实现的LRU算法示例。
假设存储容量为4，依次访问页面序列为1、2、3、1、4、5。
初始时，链表为空，哈希表为空。
- 访问页面1：1不在哈希表中，将其添加到链表头，并更新哈希表。
链表：1；哈希表：{1: 指向链表头}。
- 访问页面2：2不在哈希表中，将其添加到链表头，并更新哈希表。
链表：2->1；哈希表：{2: 指向链表头, 1: 指向链表第二个节点}。
- 访问页面3：3不在哈希表中，将其添加到链表头，并更新哈希表。
lru 页面置换算法
LRU 页面置换算法1. 简介LRU（Least Recently Used）页面置换算法是一种常用的操作系统内存管理算法，用于在内存不足时决定哪些页面应该被置换出去以腾出空间给新的页面。
LRU算法基于一个简单的原则：最近最少使用的页面应该被置换。
在计算机系统中，内存是有限的资源，而运行程序所需的内存可能超过可用内存大小。
当系统发现没有足够的空闲内存来加载新页面时，就需要选择一些已经在内存中的页面进行替换。
LRU算法就是为了解决这个问题而设计的。
2. 原理LRU算法基于一个简单的思想：如果一个页面最近被访问过，那么它将来可能会再次被访问。
相反，如果一个页面很久没有被访问过，那么它将来可能不会再次被访问。
根据这个思想，LRU算法将最近最少使用的页面置换出去。
具体实现上，可以使用一个数据结构来记录每个页面最近一次被访问的时间戳。
当需要替换一页时，选择时间戳最早（即最久未访问）的页面进行替换即可。
3. 实现方式LRU算法的实现可以基于多种数据结构，下面介绍两种常见的实现方式。
3.1 使用链表一种简单的实现方式是使用一个双向链表来记录页面的访问顺序。
链表头部表示最近访问过的页面，链表尾部表示最久未被访问过的页面。
每当一个页面被访问时，将其从原位置移动到链表头部。
当需要替换一页时，选择链表尾部的页面进行替换。
这种实现方式的时间复杂度为O(1)，但空间复杂度较高，为O(n)，其中n为内存中可用页面数。
class Node:def __init__(self, key, value):self.key = keyself.value = valueself.prev = Noneself.next = Noneclass LRUCache:def __init__(self, capacity):self.capacity = capacityself.cache = {}self.head = Node(0, 0)self.tail = Node(0, 0)self.head.next = self.tailself.tail.prev = self.headdef get(self, key):if key in self.cache:node = self.cache[key]self._remove(node)self._add(node)return node.valueelse:return -1def put(self, key, value):if key in self.cache:node = self.cache[key]node.value = valueself._remove(node)self._add(node)else:if len(self.cache) >= self.capacity:del self.cache[self.tail.prev.key] self._remove(self.tail.prev)node = Node(key, value)self.cache[key] = nodeself._add(node)def _remove(self, node):prev = node.prevnext = node.nextprev.next = nextnext.prev = prevdef _add(self, node):head_next = self.head.nextself.head.next = nodenode.prev = self.headnode.next = head_nexthead_next.prev = node3.2 使用哈希表和双向链表另一种实现方式是使用一个哈希表和一个双向链表。
页面置换常用的算法总结
页⾯置换常⽤的算法总结本⽂转载⾃：进程运⾏时，若其访问的页⾯不在内存⽽需将其调⼊，但内存已⽆空闲空间时，就需要从内存中调出⼀页程序或数据，送⼊磁盘的对换区。
选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的，因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串：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。
访问页⾯70120304230321201701物理块1777222227物理块200004000物理块31133311缺页否√√ √√√√√√√图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。
该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现FIFO、LRU和Clock算法。
二、实验原理页面置换算法是操作系统中用到的一种算法，其作用是在内存不够用时，选择牺牲已经在内存中的一些页，腾出更多的空间给新的内容。
本次实验主要实现了FIFO、LRU和Clock算法。
1、FIFO算法FIFO算法是最简单的页面置换算法，它采用先进先出的原则，即最先进入内存的页面应该最早被替换出去。
该算法的实现非常简单，只需要维护一个队列即可。
当需要置换页面时，选择队列的第一个页面进行替换即可。
2、LRU算法LRU算法是Least Recently Used的缩写，即最近最少使用算法。
该算法的核心思想是选择最久没有被使用的页面进行替换。
为了实现该算法，需要维护记录页面使用时间的链表、栈或队列等结构。
3、Clock算法Clock算法也叫做二次机会算法，是一种改良的FIFO算法。
它是基于FIFO算法的思想，并且每个页面都设置了一个使用位（use bit），用于记录该页面是否被使用过。
当需要置换一个页面时，检查该页面的使用位，如果该页面的使用位为1，则将该页面的使用位设置为0并移到队列的末尾，表示该页面有“二次机会”继续待在内存中；如果该页面的使用位为0，则选择该页面进行替换。
三、实验过程本次实验采用Python语言实现页面置换算法，并使用样例进行测试。
1、FIFO算法实现FIFO算法的实现非常简单，只需要用一个队列来维护已经在内存中的页面，当需要置换页面时，选择队列的第一个元素即可。
代码如下：```pythonfrom collections import dequeclass FIFO:def __init__(self, frame_num):self.frame_num = frame_numself.frames = deque(maxlen=frame_num)def access(self, page):if page in self.frames:return Falseif len(self.frames) >= self.frame_num:self.frames.popleft()self.frames.append(page)return True```2、LRU算法实现LRU算法的实现需要维护一个记录页面使用时间的链表或队列。
最佳页面置换算法
最佳页面置换算法(Optimal)（非常专业）评价一个算法的优劣,可通过在一个特定的存储访问序列（页面走向）上运行它，并计算缺页数量来实现。
1 先入先出法（FIFO）最简单的页面置换算法是先入先出（FIFO）法。
这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。
理由是：最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。
建立一个FIFO队列，收容所有在内存中的页。
被置换页面总是在队列头上进行。
当一个页面被放入内存时，就把它插在队尾上。
这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不高。
因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。
FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。
当然，导致这种异常现象的页面走向实际上是很少见的。
现在来看下4块的情况：0 1 2 3 2 1 3 2 5 2 3 6 2 1 4 2【解答】刚开始内存并没有这个作业，所以发生缺页中断一次。
作业的0号页进入内存。
(1次缺页中断)而页1又不在内存，又发生缺页中断一次。
作业页1进入内存。
(2次缺页中断) 页2不在内存，发生缺页中断。
页2进入内存。
(3次缺页中断)页3不在内存，发生缺页中断。
页3进入内存。
(4次缺页中断)接下来调入页2，页1，页3，页2。
由于都在内存中，并不发生缺页中断。
页5不在内存，发生缺页中断。
页5进入内存，页5置换页0。
(5次缺页中断) 接下来调入页2，页3。
由于都在内存中，并不发生缺页中断。
页6不在内存，发生缺页中断。
页6进入内存。
页6置换页1。
(6次缺页中断) 页2在内存，不发生缺页中断。
页1不在内存(在发生第6次缺页中断时被置换了)，发生缺页中断。
页1进入内存，页2被置换。
(7次缺页中断)页4置换页3，页4进入内存。
(8次缺页中断)现在调入页2，但页2在发生第7次缺页中断时被置换掉了。
NUR页面置换算法
NRU页面置换算法1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。
2）用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。
在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。
如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。
如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。
在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。
3)置换算法：最近最不经常使用（NRU）算法。
#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define N 4#define size 320typedef struct Page{int page_num;int flag_A; //访问位int flag_M; //修改位int read_or_write; //0表示不被修改,1表示被修改}PAGE;typedef struct Block{int block_num; //块号PAGE page; //所装页的信息struct Block *next;}BLOCK,*BLOCKLIST;typedef struct instruct{ //指令数据结构int address; //指令地址PAGE page; //对应页的信息}INSTRUCTION,*INSTRUCTIONLIST;INSTRUCTION instructions[size];//定义320个指令BLOCKLIST block_head; //块的头指针int diseffect=0; //缺页次数int blockSize=0;void Init_Instructions(){for(int i=0;i<320;i++)instructions[i].address=rand()%320;for(int k=0;k<320;k++){instructions[k].page.page_num=(int)instructions[k].address/10;instructions[k].page.flag_A=0;instructions[k].page.read_or_write=rand()%2;if(instructions[k].page.read_or_write==0)instructions[k].page.flag_M=0;else instructions[k].page.flag_M=1;}}BLOCKLIST Init_block(){BLOCKLIST head=(BLOCKLIST)malloc(sizeof(BLOCK)) ;BLOCKLIST p;for(int i=1;i<=N;i++) {if(i==1) p=head;else {p->next=(BLOCKLIST)malloc(sizeof(BLOCK));p=p->next;}p->block_num=i;p->page.page_num=-1;p->page.flag_A=0;p->page.flag_M=0;}p->next=head;return head;}void display(INSTRUCTION instructions){BLOCKLIST p=block_head;printf("The new page: (page_num==%d), (flag_M==%d), (address==%d)\n", instructions.page.page_num,instructions.page.flag_M,instructions.address);printf("block_num,page_num,flag_A,flag_M\n");do{printf(" %2d %10d%9d%8d\n",p->block_num,p->page.page_num,p->page.flag_A,p->page.flag_M);p=p->next;}while(p!=block_head);}void show_physical_address(BLOCKLIST &p,INSTRUCTION instructions){int address;printf("physical address:");address=p->block_num*1024+instructions.address%10;//页面大小为1kprintf("%d\n\n",address);}//查找四个块中是否有此页面int Find_page_in_block(INSTRUCTION instructions,BLOCKLIST &p){p=block_head;do{if(p->page.page_num==instructions.page.page_num){p->page.flag_A=1;if(p->page.flag_M==0)p->page.flag_M=instructions.page.flag_M;return 1;}p=p->next;}while(p!=block_head);return 0;}//先将四个块中装满void loadpage(PAGE page){BLOCKLIST p;p=block_head;while(p->page.page_num!=-1)p=p->next;p->page.page_num=page.page_num;p->page.flag_A=1;p->page.flag_M=page.flag_M;blockSize++;}//第一次循环扫描A=0 M=0int cscanf1(BLOCKLIST &p){p=block_head;do{if(p->page.flag_A==0 && p->page.flag_M==0)return 1;p=p->next;}while(p!=block_head);return 0;}//第二次循环扫描A=0 M=1int cscanf2(BLOCKLIST &p){p=block_head;do{ //把扫面过后的A=1,M=0 或A=1,M=1中的A置0if(p->page.flag_A==1 && (p->page.flag_M==0 || p->page.flag_M==1)){p->page.flag_A=0;p=p->next;continue;}if(p->page.flag_A==0 && p->page.flag_M==1)return 1;p=p->next;}while(p!=block_head);return 0;}//第三次扫描将所有的A置为0int cscanf3(BLOCKLIST &p){p=block_head;do{p->page.flag_A=0;p=p->next;}while(p!=block_head);return 1;}//用于换进页面void assignment(BLOCKLIST &p,INSTRUCTION instructions) {p->page.page_num=instructions.page.page_num;p->page.flag_A=1;p->page.flag_M=instructions.page.flag_M;}//NRU页面替换算法void replace_page(INSTRUCTION instructions,BLOCKLIST &p) {if(cscanf1(p)){assignment(p,instructions);}else if(cscanf2(p)){assignment(p,instructions);}else if(cscanf3(p)){if(cscanf1(p))assignment(p,instructions);else {cscanf2(p);assignment(p,instructions);}}}void main(){BLOCKLIST p;Init_Instructions();block_head=Init_block();for(int i=0;i<size;i++) {if(Find_page_in_block(instructions[i],p)){display(instructions[i]);show_physical_address(p,instructions[i]);getchar();continue;}else if(blockSize<N) {diseffect++;loadpage(instructions[i].page);}else {diseffect++;replace_page(instructions[i],p);}display(instructions[i]);if(diseffect>4)show_physical_address(p,instructions[i]);getchar();}printf("NRU %f\n",(float)diseffect/size);getchar();getchar();getchar();}。
opt最佳页面置换算法
opt最佳页面置换算法
OPT算法是一种最佳页面置换算法，也称为OPTIMUM算法。
该算法是根据一定的内存访问时序指令，选择在未来将要被访问的页面不在内存中的页面进行替换。
最佳页面置换算法即每次从主存中选择即将被访问时间最远的页淘汰，即未来需要最长时间不会被访问的页面。
当然，由于无法预知未来的访问模式，因此最佳页面置换算法是一种理论上的置换算法。
OPT算法的主要优点是能够最小化缺页率。
而缺点是需要在未来的所有访问模式中找到最久未被访问的页面，这是一项很耗时的操作，难以实现，并且无法处理重复访问的页面。
因此，实际应用中很少使用OPT算法。
fifo页面置换算法例题详解
fifo页面置换算法例题详解FIFO（First In, First Out）页面置换算法是一种最简单的页面置换算法，它根据页面调入内存的顺序进行页面置换。
当发生页面缺失时，选择最早调入内存的页面进行置换。
下面是一个使用FIFO页面置换算法解决页面置换问题的例题：假设一个系统的物理内存容量为3个页面，而作业需要访问9个页面。
作业在以下指令序列中运行：1，2，3，4，1，2，5，1，2。
假设在开始时，物理内存中没有页面。
使用FIFO页面置换算法，计算缺页次数。
解题步骤如下：1. 创建一个长度为3的队列，用于保存当前在内存中的页面。
2. 从指令序列中取出第一个页面1。
由于物理内存中没有页面，将页面1调入物理内存，并将1加入队列中。
3. 继续从指令序列中取出页面2。
由于物理内存中只有页面1，将页面2调入物理内存，并将2加入队列中。
4. 继续从指令序列中取出页面3。
由于物理内存中有页面1和2，将页面3调入物理内存，并将3加入队列中。
5. 继续从指令序列中取出页面4。
由于物理内存中已满，需要进行页面置换。
由于页面1是最早调入内存的页面，所以选择页面1进行置换。
将页面4调入物理内存，并将4加入队列中。
6. 继续从指令序列中取出页面1。
由于物理内存中已满，需要进行页面置换。
由于页面2是最早调入内存的页面，所以选择页面2进行置换。
将页面1调入物理内存，并将1加入队列中。
7. 继续从指令序列中取出页面2。
由于物理内存中已满，需要进行页面置换。
由于页面3是最早调入内存的页面，所以选择页面3进行置换。
将页面2调入物理内存，并将2加入队列中。
8. 继续从指令序列中取出页面5。
由于物理内存中已满，需要进行页面置换。
由于页面4是最早调入内存的页面，所以选择页面4进行置换。
将页面5调入物理内存，并将5加入队列中。
9. 继续从指令序列中取出页面1。
由于物理内存中已满，需要进行页面置换。
由于页面1是最早调入内存的页面，所以选择页面1进行置换。
页面置换算法
操作io.h> #include <stdlib.h> #include <unistd.h> #define TRUE 1 #define FALSE 0 #define INVALID -1 #define NUL 0 #define total_instruction 320 /指令流长/ #define total_vp 32 /虚页长/ #define clear_period 50 /清零周期/ typedef struct{ /页面结构/ int pn,pfn,counter,time;
谢谢观看
LRU算法是与每个页面最后使用的时间有关的。当必须置换一个页面时，LRU算法选择过去一段时间里最久未 被使用的页面。
LRU算法是经常采用的页面置换算法，并被认为是相当好的，但是存在如何实现它的问题。LRU算法需要实际 硬件的支持。其问题是怎么确定最后使用时间的顺序，对此有两种可行的办法：
1.计数器。最简单的情况是使每个页表项对应一个使用时间字段，并给CPU增加一个逻辑时钟或计数器。每 次存储访问，该时钟都加1。每当访问一个页面时，时钟寄存器的内容就被复制到相应页表项的使用时间字段中。 这样我们就可以始终保留着每个页面最后访问的“时间”。在置换页面时，选择该时间值最小的页面。这样 做， 不仅要查页表，而且当页表改变时（因CPU调度）要 维护这个页表中的时间，还要考虑到时钟值溢出的问 题。
常见的置换算法
先进先出置换算法 （FIFO）
最佳置换算法 （OPT）
最近最久未使用 （LRU）算法
这是一种理想情况下的页面置换算法，但实际上是不可能实现的。该算法的基本思想是：发生缺页时，有些 页面在内存中，其中有一页将很快被访问（也包含紧接着的下一条指令的那页），而其他页面则可能要到10、 100或者1000条指令后才会被访问，每个页面都可 以用在该页面首次被访问前所要执行的指令数进行标记。最佳 页面置换算法只是简单地规定：标记最大的页应该被置换。这个算法唯一的一个问题就是它无法实现。当缺页发 生时，操作系统无法知道各个页面下一次是在什么时候被访问。虽然这个算法不可能实现，但是最佳页面置换算 法可以用于对可实现算法的性能进行衡量比较。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
2 2 3 2 3 2 2 3 1 2 3 5 2 3 2 4 4 3 5 3 2 2 3 5 2
1
5
5
5
OPT算法
缺页次数：7次
第四章存储器管理
6/11
特点
理论上，性能最佳 实际上，无法实现
第四章存储器管理
7/11
4.7.3 最近最久未使用置换算法
思想：选择最近最久未被使用（访问）的页淘汰出去。 例3 系统为某进程分配三个物理块，页面走向2 3 2 1 5 2 4 5 3 2 5 2，采用LRU算法，计算在访问过程中 所发生的缺页次数。
1
1
1
4
4
4
2
FIFO算法
缺页次数：10次
第四章存储器管理
4/11
特点
实现简单
与进程实际的运行不相适应
第四章存储器管理
5/11
4.7.2 最佳置换算法
思想：选择以后永远（相比之下，最长时间）不会 被使用的页淘汰出去 。 例2 系统为某进程分配三个物理块，页面走向2 3 2 1 5 2 4 5 3 2 5 2，采用OPT算法，计算在访问过程 中所发生的缺页次数。
第四章存储器管理
3/11
4.7.1 先进先出页面置换算法
思想：选择最先进入系统的页淘汰出去 例1 系统为某进程分配三个物理块，页面走向2 3 2 1 5 2 4 5 3 2 5 2，采用FIFO，计算在访问 过程中所发生的缺页次数。
2 2 3 2 3 2 2 3 1 2 3 5 5 3 2 5 2 4 5 2 5 3 3 2 2 5 3 5 2 3 5
第四章存储器管理
10/11
作业
习题四
T23 预习 4.8
第四章存储器管理
11/11
操作系统
Operating System
4.7 页面置换算法
1/11
教学目标
掌握先进先出置换算法（重点） 掌握最佳置换算法（重点） 掌握最近最久未使用置换算法（ 页面置换算法
先进先出（FIFO）置换算法 最佳（OPT）置换算法 最近最久未使用（LRU）置换算法
2 2 3 2 3 2 2 3 1 2 3 5 2 5 2 4 2 5 5 3 3 5 2 3 5 5 2
1
1
4
4
2
LRU算法
缺页次数：8次
第四章存储器管理
8/11
特点：
性能较好 实现复杂，增加系统负担。
第四章存储器管理
9/11
小结
FIFO
向后看 OPT 向前看 LRU 既向后看也预测（向前看）