操作系统课程设计(LRU算法)完整版内含代码

合集下载

操作系统LRU课程设计

操作系统LRU课程设计一、课程目标知识目标：1. 理解操作系统中LRU（最近最少使用）页面置换算法的基本原理；2. 掌握LRU算法在内存管理中的应用及其对系统性能的影响；3. 学会分析不同页面置换算法的优缺点，并进行简单的比较。

技能目标：1. 能够运用所学知识编写简单的LRU页面置换算法的程序；2. 能够通过案例分析和实验操作，提升问题解决能力和团队协作能力；3. 能够运用所学知识对实际操作系统中的内存管理问题进行初步分析和优化。

情感态度价值观目标：1. 培养学生对操作系统的兴趣，激发他们主动探索和研究的精神；2. 增强学生的团队合作意识，培养他们尊重他人、共同进步的品质；3. 通过对操作系统知识的学习，引导学生认识到科技对社会发展的重要性，培养他们的社会责任感。

课程性质分析：本课程为计算机科学与技术专业的高年级课程，旨在帮助学生深入理解操作系统的内存管理原理，提高他们在实际应用中分析和解决问题的能力。

学生特点分析：学生已具备一定的编程基础和操作系统知识，具有较强的逻辑思维能力和自主学习能力。

教学要求：1. 结合实际案例，引导学生深入理解LRU算法的原理和应用；2. 强化实践操作，让学生在实践中掌握知识，提高技能；3. 注重培养学生的团队合作精神和情感态度价值观。

二、教学内容1. 引言：回顾操作系统内存管理的基本概念，引入LRU页面置换算法。

- 简要介绍内存管理的重要性；- 回顾页面置换算法的基本原理。

2. LRU算法原理：- 讲解LRU算法的核心思想；- 分析LRU算法在内存管理中的作用；- 介绍LRU算法的优缺点。

3. LRU算法实现：- 介绍LRU算法的常见实现方法；- 演示如何编写简单的LRU页面置换算法程序；- 分析不同实现方法对性能的影响。

4. 案例分析与实验：- 结合实际案例，分析LRU算法在实际操作系统中的应用；- 安排实验，让学生动手实现和优化LRU算法；- 讨论实验过程中的问题及解决方案。

《操作系统》课程设计

《操作系统》课程设计一、课程目标知识目标：1. 让学生掌握操作系统的基本概念，包括进程、线程、内存管理、文件系统等核心知识；2. 了解操作系统的历史发展，掌握不同类型操作系统的特点及使用场景；3. 掌握操作系统的性能评价方法和常用的调度算法。

技能目标：1. 培养学生运用操作系统知识解决实际问题的能力，如分析系统性能瓶颈、优化系统资源分配等；2. 培养学生具备基本的操作系统编程能力，如进程创建、线程同步、文件操作等；3. 提高学生的团队协作能力和沟通能力，通过小组讨论和项目实践，学会共同解决问题。

情感态度价值观目标：1. 培养学生对操作系统学科的兴趣，激发学生的学习热情，使其形成积极向上的学习态度；2. 培养学生具备良好的信息素养，尊重知识产权，遵循法律法规；3. 培养学生的创新精神和批判性思维，敢于质疑、勇于探索，形成独立思考的能力。

课程性质：本课程为计算机科学与技术专业的核心课程，旨在让学生掌握操作系统的基本原理和实现方法，提高学生的系统分析和编程能力。

学生特点：学生具备一定的编程基础和计算机系统知识，具有较强的逻辑思维能力和动手实践能力。

教学要求：结合学生特点和课程性质，注重理论与实践相结合，通过案例分析和项目实践，帮助学生将所学知识内化为具体的学习成果。

在教学过程中，关注学生的学习进度和反馈，及时调整教学策略，确保课程目标的实现。

二、教学内容1. 操作系统概述：介绍操作系统的定义、发展历程、功能、类型及特点，对应教材第一章内容。

- 操作系统的起源与发展- 操作系统的功能与类型- 操作系统的主要特点2. 进程与线程：讲解进程与线程的概念、状态、调度算法，对应教材第二章内容。

- 进程与线程的定义与区别- 进程状态与转换- 进程调度算法3. 内存管理：分析内存管理的基本原理、策略和技术，对应教材第三章内容。

- 内存分配与回收策略- 虚拟内存技术- 页面置换算法4. 文件系统：介绍文件系统的基本概念、结构、存储原理，对应教材第四章内容。

操作系统课程设计面置换算法LRU算法

实验报告实验说明：执行程序时，当主存没有可用页面时，为了选择淘汰主存中的哪一页面，腾出1个空闲块以便存放新调入的页面。

淘汰哪个页面的首要问题是选择何种置换算法。

该程序采用LRU 方法选择，依置换策略选择一个可置换的页面并计算它们的缺页率以便比较。

包括实验内容及条件) 主要参考书计算机操作系统原理操作系统算法流程图:西安大学出版社电子工业出版社汤子涵主编 William Stallings 著主更算法流程图(包括实验步骤int ijndex=-l;for(i=0;i<M;i++){if(a[i]=-l){index=i;break:return index;void swap(int x){int i,k,temp,tempO;int index=isIn(xjeg|O]); /****判断x 是否在reg[O]数组中*******/if(index!=-l){reg[ 1 ][index]=reg[ 1 ] [index] A N; /**reg[ 1 ] [index]异或二进制数10000000**/}else{temp=isFull(reg[OJ);if(temp!=-l){ /*******内存没有满，直接调入页而************/reg[O][temp]=x;reg[ l][temp]=reg( l][tcnip]A N;}else if(temp==-l){k=min(reg[l ]);/**置换出寄存器中数值最小的对应的下标的页面***/tenipO=reg[O][k]; /*********临时保留要换出的页而号*****/ reg[O][k]=x;reg[l][k]=reg[l](kpN:printf(M the page %d is exchanged out!\n M,tempO);/******打印要置换出的页号** ******* *****/count++; /*********g 换次数加1 ♦*****♦*♦*****/ }}for(i=0;i<M;i++){reg[l][i]=reg[l][i]»l;/******** 寄存器中的所有数右移一位 *****/ }}niain(){ int x;system("cls");init();printfC^Input a sort of pages\n n); printf(v while you input -1 Jt will stop!\n H);scanf(M%d M,&x);/********输入页面号，宜到页而号为-!*♦*******/ while(x!=-l){num++; /*******输入的页而次数加1枠**#粋/swap(x);scanf(,r%d,\&x);}/** ****** *******打印缺页数和缺页率******* *** **** ****“$*/ printf(u the count of Exchanged is: %d \n H,count);printf(u the rate of exchanged is: %f\n,\count* 1.0/nuni); getch();)本次实践计划. 进度安排及完成情况05月09号商讨如何实现本次实验以及同学之间的分工. 05月10号査阅相关资料.05月16号~05月17号基本完成程序修改完善程序.代码测试.完成实验报告.主要测试方法及测试数据，包括测试结果及实验结果：Input a sort of pageswhile you input ~1 , it will stop! 712the page 7 is exchanged out!3the page 1 is exchanged out!4the page 2 is exchanged out!2the page 3 is exchanged out!43the page 0 is exchanged out!the page 2 is exchanged out!。

操作系统课程设计(完整规范版)

操作系统课程设计（完整规范版）一、设计目的操作系统课程设计旨在让学生深入了解操作系统的基本原理，掌握操作系统的设计与实现方法，培养学生在实际操作系统中分析和解决问题的能力。

通过本次课程设计，学生将能够：1. 加深对操作系统理论知识的理解与应用；2. 提高动手实践能力，培养创新精神和团队协作意识；3. 为今后从事操作系统相关领域的研究和工作奠定基础。

二、设计要求（1）进程管理：包括进程的创建、撤销、调度等；（2）内存管理：实现内存分配、回收、页面置换等；（3）文件系统：实现文件的创建、删除、读写等操作；（4）设备管理：实现设备的分配、回收、驱动等功能。

（1）代码规范：编写清晰、易读、易维护的代码；（3）团队协作：合理分工，确保团队成员共同参与、共同进步。

三、设计步骤1. 需求分析：分析课程设计所需实现的功能，明确各个模块的具体要求；2. 概要设计：根据需求分析，制定总体设计方案，划分模块，确定模块间接口；3. 详细设计：针对每个模块，进行具体实现方案的设计；4. 编码实现：按照设计文档，编写代码，实现各个功能模块；5. 测试与调试：对实现的功能进行测试，发现问题并进行调试；6. 优化与改进：根据测试结果，对代码进行优化，提高系统性能；四、预期成果1. 完成一套具有基本功能的模拟操作系统，能够演示进程管理、内存管理、文件系统和设备管理的主要操作；2. 提供完整的，包括注释，以便他人理解和学习；3. 形成一份详尽的课程设计报告，记录设计过程中的思考、遇到的问题及解决方案；4. 通过课程设计，提升个人在操作系统领域的理论知识和实践能力。

五、评价标准1. 功能完整性：各功能模块是否按照要求实现，系统是否能正常运行；3. 创新性：设计过程中是否有独特的想法，是否对现有技术有所改进；4. 团队协作：团队成员之间沟通是否顺畅，分工是否合理，协作是否高效；5. 文档质量：课程设计报告是否详细、准确，是否能够完整反映设计过程和成果。

LRU算法C语言实现

LRU算法C语言实现LRU（Least Recently Used）算法是一种常见的缓存替换算法，它根据数据最近被访问的时间进行缓存替换。

当缓存满时，LRU算法将替换最长时间未被访问的数据。

下面是使用C语言实现LRU算法的代码：```c#include <stdio.h>#include <stdlib.h>typedef struct nodeint key;int value;struct node *prev;struct node *next;} Node;typedef struct lru_cacheint capacity;int count;Node *head;Node *tail;Node **hashmap;} LRUCache;LRUCache *createCache(int capacity)LRUCache *cache = (LRUCache *)malloc(sizeof(LRUCache)); cache->capacity = capacity;cache->count = 0;cache->head = NULL;cache->tail = NULL;cache->hashmap = (Node **)malloc(sizeof(Node *) * capacity); // 初始化hashmap为NULLfor (int i = 0; i < capacity; i++)cache->hashmap[i] = NULL;}return cache;void addNodeToHead(LRUCache *cache, Node *node)//将节点添加到链表头部node->next = cache->head;node->prev = NULL;if (cache->head != NULL)cache->head->prev = node;}cache->head = node;if (cache->tail == NULL)cache->tail = node;}void removeNode(LRUCache *cache, Node *node) //移除节点if (node->prev != NULL)node->prev->next = node->next;} elsecache->head = node->next;}if (node->next != NULL)node->next->prev = node->prev;} elsecache->tail = node->prev;}void moveToHead(LRUCache *cache, Node *node)//将节点移动到链表头部removeNode(cache, node);addNodeToHead(cache, node);void removeTail(LRUCache *cache)//移除链表尾部的节点if (cache->tail != NULL)Node *node = cache->tail;cache->tail = node->prev;if (node->prev != NULL)node->prev->next = NULL;} elsecache->head = NULL;}free(node);}int get(LRUCache *cache, int key)//根据键值获取缓存值，并将节点移动到链表头部int hash = abs(key) % cache->capacity;Node *node = cache->hashmap[hash];while (node != NULL)if (node->key == key)moveToHead(cache, node);return node->value;}node = node->next;}//如果节点不存在，返回-1return -1;void put(LRUCache *cache, int key, int value)//添加或更新缓存键值对int hash = abs(key) % cache->capacity;Node *node = cache->hashmap[hash];//如果缓存中已存在该键值对，更新节点的值并移动到链表头部while (node != NULL)if (node->key == key)node->value = value;moveToHead(cache, node);return;}node = node->next;}// 如果缓存已满，移除链表尾部的节点，同时更新hashmap if (cache->count >= cache->capacity)int tailKey = cache->tail->key;removeTail(cache);cache->hashmap[abs(tailKey) % cache->capacity] = NULL; cache->count--;}// 创建新的节点，并添加到链表头部和hashmapNode *newNode = (Node *)malloc(sizeof(Node)); newNode->key = key;newNode->value = value;newNode->prev = NULL;newNode->next = NULL;addNodeToHead(cache, newNode);cache->hashmap[hash] = newNode;cache->count++;void destroyCache(LRUCache *cache)//销毁缓存Node *node = cache->head;while (node != NULL)Node *temp = node;node = node->next;free(temp);}free(cache->hashmap);free(cache);```上述代码中，我们定义了两个数据结构，`Node`表示缓存中的节点，`LRUCache`表示整个缓存。

操作系统lru算法

操作系统lru算法LRU（Least Recently Used）算法是一种置换算法，也称为最近最少使用算法。

该算法的基本思想是每次淘汰最近最少使用（最近一段时间内没有被使用）的页面。

LRU算法的实现可以采用多种数据结构，如链表、双向链表、队列等。

下面介绍一种基于双向链表和哈希表的实现。

首先定义一个双向链表节点，包含页面的编号和指向前一个节点和后一个节点的指针。

cppstruct node {int key; 页面编号node* prev; 前驱节点node* next; 后继节点};定义一个哈希表，根据页面的编号映射到对应的链表节点，在每个节点上存储页面的内容。

cppstruct cache {unordered_map<int, node*> map; 哈希表int capacity; 缓存大小node* head; 链表头node* tail; 链表尾};具体实现LRU算法的主要操作有两个：插入新页面和淘汰页面。

插入新页面时，先判断页面是否已经在缓存中。

如果已经在缓存中，则将该节点移到链表头部，表示最近使用过；如果不在缓存中，则需要新建一个节点插入到链表头部，并将其加入哈希表。

cppvoid put(cache& c, int key, int val) {判断是否已存在于缓存中auto it = c.map.find(key);if (it != c.map.end()) {移到链表头部node* p = it->second;p->prev->next = p->next;p->next->prev = p->prev;p->next = c.head->next;p->prev = c.head;c.head->next->prev = p;c.head->next = p;更新节点的值p->val = val;} else {创建新节点node* p = new node{key, val, c.head, c.head->next};c.head->next->prev = p;c.head->next = p;添加到缓存和哈希表c.map[key] = p;如果超出缓存大小则需要淘汰if (c.map.size() > c.capacity) {node* p = c.tail->prev;p->prev->next = c.tail;c.tail->prev = p->prev;c.map.erase(p->key);delete p;}}}淘汰页面时，直接将链表尾部的节点删除，并将对应的哈希表项删除。

lru算法c语言

lru算法c语言LRU算法是Least Recently Used的缩写，即最近最少使用算法。

它是一种用于页面置换的算法，主要用于操作系统中对内存进行管理。

其基本思想是将最近最少使用的页面淘汰掉，从而保留当前正在使用的页面。

在实现LRU算法时，需要使用一个数据结构——双向链表。

链表中每个节点都表示一个页面，其中包含了该页面的编号、访问时间等信息。

当访问一个页面时，如果该页面已经存在于链表中，则将其移到链表头部；如果该页面不存在于链表中，则将其加入链表头部，并删除链表尾部的节点。

以下是C语言实现LRU算法的代码：```c#include <stdio.h>#include <stdlib.h>#define CACHE_SIZE 4typedef struct Node {int data;struct Node* prev;struct Node* next;} Node;Node* head = NULL;Node* tail = NULL;int cache[CACHE_SIZE];int cache_index = 0;void insert(int data) {// 如果缓存未满，则直接插入新节点到双向链表头部 if (cache_index < CACHE_SIZE) {Node* node = (Node*)malloc(sizeof(Node)); node->data = data;node->prev = NULL;node->next = head;if (head == NULL) {tail = node;} else {head->prev = node;}head = node;cache[cache_index++] = data;} else {// 如果缓存已满，则删除双向链表尾部节点，并将新节点插入到头部int last_data = tail->data;Node* last_node = tail;tail = tail->prev;if (tail != NULL) {tail->next = NULL;} else {head = NULL;}free(last_node);Node* node = (Node*)malloc(sizeof(Node));node->data = data;node->prev = NULL;node->next = head;if (head == NULL) {tail = node;} else {head->prev = node;}head = node;for (int i = 0; i < CACHE_SIZE; i++) { if (cache[i] == last_data) {cache[i] = data;break;}}}}void print_cache() {printf("Cache: ");for (int i = 0; i < CACHE_SIZE; i++) { printf("%d ", cache[i]);}printf("\n"); }int main() {insert(1);print_cache();insert(2);print_cache();insert(3);print_cache();insert(4);print_cache();insert(5);print_cache();insert(6);print_cache();return 0;}```在上述代码中，我们使用了一个数组cache来保存当前缓存中的页面编号。

lru算法 java实现

lru算法 java实现LRU（LeastRecentlyUsed）算法是一种常用的缓存淘汰策略，它根据数据最近使用的频率来淘汰缓存中的数据。

在Java中，可以使用哈希表和双向链表来实现LRU算法。

一、实现思路1.创建一个哈希表来存储缓存数据，使用键值对的形式表示缓存中的数据和对应的访问时间。

2.创建一个双向链表，用于存储缓存数据的访问顺序。

最近使用的数据会放在链表的头部，最久未使用的数据会放在链表的尾部。

3.在访问缓存数据时，如果数据不存在于哈希表中，则需要将数据添加到哈希表中，并更新其访问时间。

如果数据已经存在于哈希表中，则需要更新其访问时间并移动到链表的头部。

4.在需要淘汰缓存数据时，可以遍历链表并依次删除头部节点，直到只剩下最后一个节点为止。

最后需要将最后一个节点所代表的数据从哈希表中删除。

二、代码实现下面是一个基于上述思路的LRU算法的Java实现示例：```javaimportjava.util.HashMap;importjava.util.Map;publicclassLRUCache{privateintcapacity;privateHashMap<Integer,Node>cacheMap;privateLinkedList<Integer>list;publicLRUCache(intcapacity){this.capacity=capacity;this.cacheMap=newHashMap<>();this.list=newLinkedList<>();}publicintget(intkey){if(!cacheMap.containsKey(key)){return-1;//缓存中不存在该键值对，返回-1表示失败}Nodenode=cacheMap.get(key);//获取该键值对的节点对象list.remove(node);//从链表中移除该节点list.addFirst(key);//将该节点移动到链表头部表示最近使用过returnnode.value;//返回该节点的值}publicvoidput(intkey,intvalue){if(cacheMap.containsKey(key)){//如果缓存中已经存在该键值对，更新其访问时间并移动到链表头部Nodenode=cacheMap.get(key);node.accessTime=System.currentTimeMillis();//更新访问时间并从链表中移除该节点list.remove(node);//从链表中移除该节点list.addFirst(node);//将该节点移动到链表头部表示最近使用过}else{//如果缓存中不存在该键值对，则需要添加新节点并更新其访问时间，同时将其放入链表头部表示最近使用过NodenewNode=newNode(key,System.currentTimeMillis(),value) ;//创建新节点对象cacheMap.put(key,newNode);//将新节点添加到哈希表中list.addFirst(newNode);//将新节点移动到链表头部表示最近使用过if(cacheMap.size()>capacity){//如果缓存已满，需要淘汰链表尾部的节点和对应的键值对数据NodetailNode=list.removeTail();//移除链表尾部的节点和对应的键值对数据并返回该节点对象（用于后续处理）cacheMap.remove(tailNode.key);//从哈希表中删除对应的键值对数据}}}}```其中，Node类表示一个缓存数据节点对象，包含键（key）、访问时间（accessTime）、值（value）等属性。

操作系统课程设计报告题目及代码

题目一模拟操作系统设计设计一个模拟操作系统管理程序，实现以下管理功能：1．内存管理功能2．文件管理功能3．磁盘管理功能题目二虚拟存储器各页面置换算法的实现与比较内容：设计一个虚拟存储区和内存工作区，通过产生一个随机数的方法得到一个页面序列，假设内存给定的页面数由键盘输入，分别计算使用下述各方法时的内存命中率：先进先出算法〔FIFO〕、最近最少使用算法〔LRU〕、最正确淘汰算法〔OPT〕、最少页面算法〔LFU〕等。

题目三文件系统设计通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能及内部实现。

内容：为Linu*系统设计一个简单的二级文件系统，以实现以下功能：1．可以实现以下几条命令（1）login 用户登录（2）dir 文件目录列表（3）creat 创立文件（4）delete 删除文件（5）open 翻开文件（6）close 关闭文件（7）read 读文件（8）write 写文件2．实验提示〔1〕首先确定文件系统的数据构造：主目录、子目录及活动文件等。

主目录和子目录都以文件的形式存放在磁盘，这样便于查找和修改。

〔2〕用户创立的文件，可以编号存储于磁盘上。

如file0、file1、file2……等，并以编号作为物理地址，在目录中进展登记。

[清华大学?操作系统教程? *丽芬编著题目四设计一个按时间片轮转法进程CPU调度的程序。

提示：〔1〕假设系统有5个进程，每个进程用一个进程控制块PCB来代表，PCB中包含进程名、指针、到达时间、估计运行时间、进程状态表。

其中，进程名即为进程进标识。

〔2〕为每一个进程设计一个要示运行时间和到达时间。

〔3〕按照进程到达的先后顺序排成一个循环队列，再设一个队首指针指向第一个到达的进程首址。

〔4〕执行处理机调度时，开场选择队首的第一个进程运行。

另外再设一个当前运行进程指针，指向当前正运行的进程。

〔5〕由于本实验是模拟实验，所以对被选中进程并不实际启运运行，只是执行：a.估计驼行时间减1b.输出当前运行进程的名字。

lru算法课程设计

lru算法课程设计一、教学目标本课程的目标是让学生掌握LRU算法的基本原理和实现方法。

通过本课程的学习，学生将能够理解LRU算法的内存管理机制，以及如何将其应用于缓存管理。

具体的教学目标如下：1.了解LRU算法的背景和应用场景。

2.掌握LRU算法的基本原理和实现方法。

3.理解LRU算法在缓存管理中的作用和优势。

4.能够编写简单的LRU算法实现代码。

5.能够运用LRU算法解决实际问题。

情感态度价值观目标：1.培养学生的创新意识和解决问题的能力。

2.培养学生对计算机科学和算法的兴趣和热情。

二、教学内容本课程的教学内容主要包括以下几个部分：1.LRU算法的基本原理：介绍LRU算法的背景和应用场景，讲解LRU算法的内存管理机制。

2.LRU算法的实现方法：讲解LRU算法的具体实现步骤，包括数据结构的定义和操作方法。

3.LRU算法的应用案例：通过实际案例分析，让学生了解LRU算法在缓存管理中的应用和效果。

三、教学方法为了达到本课程的教学目标，将采用以下教学方法：1.讲授法：通过讲解LRU算法的基本原理和实现方法，让学生掌握相关知识。

2.讨论法：通过分组讨论和问题解答，激发学生的思考和解决问题的能力。

3.案例分析法：通过分析实际应用案例，让学生了解LRU算法在缓存管理中的应用。

4.实验法：通过编写代码实现LRU算法，培养学生的动手能力和实际应用能力。

四、教学资源为了支持本课程的教学内容和教学方法的实施，将准备以下教学资源：1.教材：选择一本关于数据结构和算法的教材，作为学生学习的参考。

2.参考书：推荐一些关于LRU算法的相关论文和书籍，供学生深入研究。

3.多媒体资料：制作PPT和教学视频，辅助学生理解和掌握LRU算法。

4.实验设备：提供计算机和编程环境，让学生能够编写代码实现LRU算法。

五、教学评估为了全面、客观地评估学生的学习成果，将采用以下评估方式：1.平时表现：通过观察学生在课堂上的参与程度、提问和回答问题的表现，评估学生的学习态度和理解程度。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

操作系统课程设计LRU页面调度算法
学号：
姓名：
学院：
专业：
班级：
指导老师：
日期：
目录
一、实验题目 (1)
二、课程设计的目的 (1)
三、设计容 (1)
四、设计要求 (1)
五、设计思想 (1)
六、主要数据结构及其说明 (2)
七、硬件支持 (3)
八、源程序文件 (3)
九、程序运行结果 (7)
十、实验体会 (8)
一实验题目
LRU页面调度算法
二课程设计的目的
操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。

1.进一步巩固和复习操作系统的基础知识。

2. 培养学生结构化程序、模块化程序设计的方法和能力。

3.提高学生调试程序的技巧和软件设计的能力。

4.提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。

三设计容
程序应模拟实现LRU算法思想，对n个页面实现模拟调度。

四设计要求
1．不同的功能使用不同的函数实现（模块化），对每个函数的功能和调用接口要注释清楚。

对程序其它部分也进行必要的注释。

2．对系统进行功能模块分析、画出总流程图和各模块流程图。

3．用户界面要求使用方便、简洁明了、美观大方、格式统一。

所有功能可以反复使用，最好使用菜单。

4．通过命令行相应选项能直接进入某个相应菜单选项的功能模块。

5．所有程序需调试通过。

五设计思想
最近最久未使用（LRU）页调度算法是选择最近最久未使用的页面予以淘汰。

算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间，当所要访问的页面在存块中时，就不淘汰页面，否则，淘汰页面中时间最长的，即淘汰最近最久未使用的页面。

算法流程图
六主要数据结构及其说明
程序执行是稳定的，高效的。

在LRU算法中，要找出最近最久未使用的页面的话，就必须设置有关的访问记录项，且每一次访问这些记录项，叶面都必须更新这些记录项。

这个记录项在此程序中为：
typedef struct page
{
int num;/*记录页面号*/
int time;/*记录调入存时间*/
}Page;//页面逻辑结构，结构为方便算法实现设计
如此，显然要花费较大的系统开销（包括时间和空间上的），这也是实际系统中不采用LRU算法的直接原因，但由于其页面置换的优越性，实际系统中常使用LRU的近似算法。

七硬件支持
为了了解一个进程在存中的各个页面各有多少时间未被进程访问，以及如何快速的知道哪一页是最近最久未使用的页面，须有两类硬件之一的支持：寄存器或栈。

寄存器：为了记录某进程在存中各页的使用情况，须为每个在存中的页面配置一个移位寄存器。

栈：可利用一个特殊的栈来保存当前使用的各个页面的页面号。

每当进程访问某页面时，便将该页面的页面号从战中移出，将它压入栈顶。

因此，栈顶始终是最新被访问页面的编号，而栈底则是最近最久未使用页面的页面号。

八源程序文件
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define M 3 //物理块数
#define N 10 //页面数
#define Myprintf1
printf("\t************************\t\t\n\n");//表格控制
#define Myprintf2
printf("******************************\n\n");//表格控制
typedef struct page
{
int num;/*记录页面号*/
int time;/*记录调入存时间*/
}Page;//页面逻辑结构，结构为方便算法实现设计
Page b[M];//存单元数
int c[M][N];//暂保存存当前的状态：缓冲区
int queue[100];//记录调入队列
int K;//调入队列计数变量
//初始化存单元、缓冲区
void Init(Page *b,int c[M][N])
{
int i,j;
for(i=0;i<N;i++)
{
b[i].num=-1;
b[i].time=N-i-1;
}
for(i=0;i<M;i++)
for(j=0;j<N;j++)
c[i][j]=-1;
}
//取得在存中停留最久的页面，默认状态下为最早调入的页面int GetMax(Page *b)
{
int i;
int max=-1;
int tag=0;
for(i=0;i<M;i++)
{
if(b[i].time>max)
{
max=b[i].time;
tag=i;
}
}
return tag;
}
//判断页面是否已在存中
int Equation(int fold,Page *b)
{
int i;
for(i=0;i<M;i++)
{
if(fold==b[i].num)
return i;
}
return -1;
}
//LRU核心部分
void Lru(int fold,Page *b)
{
int i;
int val;
val=Equation(fold,b);
if(val>=0)
{
b[val].time=0;
for(i=0;i<M;i++)
if(i!=val)
b[i].time++;
}
else
{
queue[++K]=fold;//记录调入页面
val=GetMax(b);
b[val].num=fold;
b[val].time=0;
for(i=0;i<M;i++)
if(i!=val)
b[i].time++;
}
}
//主程序
void main()
{
start:K=-1;
int i,j;
int a[N];
Myprintf1;
printf("\n\t\t\t欢迎使用LRU页面调度算法\n\n"); Myprintf1;
printf("请输入所要访问的各个页面号：\n");
for(i=0;i<N;i++)
scanf("%d",&a[i]);
Init(b,c); //调用
for(i=0;i<N;i++)
{
Lru(a[i],b);
c[0][i]=a[i];
//记录当前的存单元中的页面
for(j=0;j<M;j++)
c[j][i]=b[j].num;
}
//结果输出
printf("存状态为:\n");
Myprintf2;
for(j=0;j<N;j++)
printf("|%2d",a[j]);
printf("|\n");
Myprintf2;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
if(c[i][j]==-1)
printf("|%2c",32);
else
printf("|%2d",c[i][j]);
}
printf("|\n");
}
Myprintf2;
printf("\n调入队列为：");
for(i=0;i<K+1;i++)
printf("%3d",queue[i]);
printf("\n缺页次数为:%6d\n缺页率:%16.6f",K+1,(float)(K+1)/N);
printf("\n是否继续!\t y?");
char y;
if(getch()=='y')
{
system("cls");
printf("\n");
goto start;
}
else
printf("\n");
printf("程序结束\n");
}
九程序运行结果
十实验体会
通过本次课程设计，对LRU页面调度算法有了更深入的理解和掌握，进一步的巩固和复习了操作系统中关于LRU页面调度算法的知识，进一步的了解了
结构化、模块化程序设计的方法，提高了编写和调试程序的技巧，老师的细心指导。