操作系统含课程设计
Ⅰ 我的操作系统课程设计,希望高手给解答一下
下面是我们实验的材料，你可以看一下，基本一样，只要把main函数中线程创建的代码根据读取的数据改一下就行了。
例2：用信号量实现的读者写者问题
读者写者问题也是一个典型的同步互斥问题。考虑一个数据库系统，多个执行实体同时
对数据库进行读操作肯定是没有问题的，但只要有一个执行实体在对数据库进行写操作时，
其他执行实体不论是读还是写，均不能进行。
在我们的例子中我们使用3 个线程模拟读者的行为，2 个线程模拟写者的行为。3 个读
者的行为基本类似，2 个写者的行为也基本类似。5 个线程之间的同步互斥机制使用信号量。
假定读者和写者要访问的公共数据为一个字符型的全局变量bookcontent，3 个读线程的行
为是不断地读取这个变量的值，并将其输出。为了使得大家能够较清楚地看到线程的运行结
果，我们在程序中插入了一些随机睡眠的代码，以便于读线程能够执行得“慢”一些，能够
有较多的机会主动放弃CPU 的占有。另外，程序中定义了两个句柄m_h 和db_h，分别指向
两个信号量，其中m_h 用于互斥访问读者计数变量rc，db_h 用于读者与写者以及写者与写
者之间的互斥。下面是三个读者的代码。
// readerwriter.cpp
//
#include "stdafx.h"
#include "stdio.h"
#include "windows.h"
#define MAX_DELAY_READER 10
#define MAX_DELAY_WRITER 100
char bookcontent='?';
int rc=0;
HANDLE m_h,db_h,r_h[3],w_h[2];
DWORD WINAPI reader1(PVOID pvParam) {
int n;
while (1) {
printf("The reader 1 is trying to entry the lib\n");
WaitForSingleObject(m_h,INFINITE);
rc++;
if (rc==1) WaitForSingleObject(db_h,INFINITE);
ReleaseSemaphore(m_h,1,NULL);
printf("The reader 1 is reading\n");
n=rand()%MAX_DELAY_READER;
Sleep(n);
printf("The result of reader 1 is %c\n",bookcontent);
printf("The reader 1 is trying to leave lib\n");
WaitForSingleObject(m_h,INFINITE);
rc--;
if (rc==0) ReleaseSemaphore(db_h,1,NULL);
ReleaseSemaphore(m_h,1,NULL);
printf("The reader 1 has left lib, and doing some other thing\n");
n=rand()%MAX_DELAY_READER;
Sleep(n);
}
return 0;
}
DWORD WINAPI reader2(PVOID pvParam) {
int n;
while (1) {
printf("Thereader 2 is trying to entry the lib\n");
WaitForSingleObject(m_h,INFINITE);
rc++;
if (rc==1) WaitForSingleObject(db_h,INFINITE);
ReleaseSemaphore(m_h,1,NULL);
printf("The reader 2 is reading\n");
n=rand()%MAX_DELAY_READER;
Sleep(n);
printf("The result of reader 2 is %c\n",bookcontent);
printf("The reader 2 is trying to leave lib\n");
WaitForSingleObject(m_h,INFINITE);
rc--;
if (rc==0) ReleaseSemaphore(db_h,1,NULL);
ReleaseSemaphore(m_h,1,NULL);
printf("The reader 2 has left lib, and doing some other thing\n");
n=rand()%MAX_DELAY_READER;
Sleep(n);
}
return 0;
}
DWORD WINAPI reader3(PVOID pvParam) {
int n;
while (1) {
printf("The reader 3 is trying to entry the lib\n");
WaitForSingleObject(m_h,INFINITE);
rc++;
if (rc==1) WaitForSingleObject(db_h,INFINITE);
ReleaseSemaphore(m_h,1,NULL);
printf("The reader 3 is reading\n");
n=rand()%MAX_DELAY_READER;
Sleep(n);
printf("The result of reader 3 is %c\n",bookcontent);
printf("The reader3 is trying to leave lib\n");
WaitForSingleObject(m_h,INFINITE);
rc--;
if (rc==0) ReleaseSemaphore(db_h,1,NULL);
ReleaseSemaphore(m_h,1,NULL);
printf("The reader 3 has left lib, and doing some other thing\n");
n=rand()%MAX_DELAY_READER;
Sleep(n);
}
return 0;
}
同样，2个写者的行为也是类似的。即一个写者不断地循环，将全局变量bookcontent
依次改写为小写字母a-z，另一个写者也是不断地循环，将全局变量bookcontent依次改写为
数字0-9。代码如下：
DWORD WINAPI writer1(PVOID pvParam) {
int n;
for (char c='a';c<='z';c++) {
printf("The writer 1 is preparing a data\n");
n=rand()%MAX_DELAY_WRITER;
Sleep(n);
printf("The writer 1 is trying to enter lib\n");
WaitForSingleObject(db_h,INFINITE);
printf("The writer 1 is wrinting a data\n");
n=rand()%MAX_DELAY_WRITER;
Sleep(n);
bookcontent=c;
ReleaseSemaphore(db_h,1,NULL);
printf("The writer 1 has left lib\n");
}
return 0;
}
DWORD WINAPI writer2(PVOID pvParam) {
int n;
for (char c='0';c<='9';c++) {
printf("The writer 2 is preparing a data\n");
n=rand()%MAX_DELAY_WRITER;
Sleep(n);
printf("The writer 2 is trying to enter lib\n");
WaitForSingleObject(db_h,INFINITE);
printf("The writer 2 is wrinting a data\n");
n=rand()%MAX_DELAY_WRITER;
Sleep(n);
bookcontent=c;
ReleaseSemaphore(db_h,1,NULL);
printf("The writer 2 has left lib\n");
}
return 0;
}
主函数中首先创建了两个信号量分别用于互斥访问读者计数变量rc和读者与写者之间
以及写者与写者之间的互斥，返回的句柄为m_h和db_h，然后创建了3个读者线程和两个写者
线程，并使其执行。
int main(int argc, char* argv[]) {
m_h=CreateSemaphore(NULL,1,1,NULL);
db_h=CreateSemaphore(NULL,1,1,NULL);
r_h[0]=CreateThread(NULL,0,reader1,NULL,0,NULL);
r_h[1]=CreateThread(NULL,0,reader2,NULL,0,NULL);
r_h[2]=CreateThread(NULL,0,reader3,NULL,0,NULL);
w_h[0]=CreateThread(NULL,0,writer1,NULL,0,NULL);
w_h[1]=CreateThread(NULL,0,writer2,NULL,0,NULL);
WaitForMultipleObjects(3,r_h,TRUE,INFINITE);
WaitForMultipleObjects(2,w_h,TRUE,INFINITE);
return 0;
}
程序编译连接之后就可运行了。注意，与例1类似，连接时需要指定使用多线程静态库
LIBCMT.LIB或多线程动态库MSVCRT.LIB。下面是程序运行的结果：
19
如果我们在创建信号量时，指定了信号量的名字，在程序执行时，暂停程序的输出，
然后运行winobj，在winobj中会看到我们创建的信号量。程序运行结束后，在winobj中我们
发现程序创建的信号量不存在了。
Ⅱ 操作系统课程设计报告
题 目 : [课程设计] 操作系统课程设计报告
尺 寸 : 操作系统课程设计_进程调度.doc
目 录 : 不存在
原 文 : 通过大三第一学期的操作系统学习，我们对操作系统的基本概念，原理及实现技术都有了一定的了解，也为我们这次的课程设计做好了理论上的准备。通过学习与交流我们这次在李长悦老师的带领下进行了为期一周的课程设计。为我们更好的巩固已学习的知识及培养我们的动手能力创造了良好的机会。
这次课程设计主要是进行进程调度的虚拟实现，在课程设计以前李老师就把调度原则告诉了我们：
一 进程调度
1．调度原则
采用动态优先数调度与时间片相结合的调度算法。首先从就绪队列（按优先数从高到低排列）中选取一个将要投入运行的进程，投入运行1秒钟（至多一秒钟。以一秒钟作为时间片），若在规定的时间片内进程未完成运行，则让出CPU，该进程的运行时间减1，并按下列优先数重新确定进程的优先数，即：
新优先数=原优先数*0.8+10/剩余时间
接着将该进程重新插入就绪队列，重新从就绪队列选取下一个合适的进程再投入运行。
2．进程数据结构
关键词 : 课程设计 操作系统 进程调度 实习报告
Ⅲ 操作系统含课程设计1.os的作用可表现在哪几个方面
设计题目
1设计题目：CPU调度(CPU调度算模拟实现)
具体内容：编写算实现CPU调度算FCFS、非抢占SJF、抢占优先权调度、RR
针模拟进程利用CPU调度算进行调度
进行算评价计算平均周转间平均等待间
要求：调度所需进程参数由输入产
手工输入
随机数产
输调度结
输鸡掸惯赶甙非轨石憨算评价指标
2设计题目：虚拟内存 (页面置换算模拟实现)
具体内容：编写算实现页面置换算FIFO、LRU
针内存址引用串运行页面置换算进行页面置换
要求：算所需引用串参数由输入产：由手工输入基于随机数产
输内存驻留页面集合
1．进程调度算模块
[问题描述]
1、进程调度算：采用态高优先数优先调度算（即处理机配给优先数高进程）
2、每进程进程控制块（ PCB）表示进程控制块包含信息：
进程名---进程标示数 ID
优先数 PRIORITY 优先数越优先权越高
达间---进程达间进程输入间、
进程需要运行间ALLTIME进程运行完毕ALLTIME=0
已用CPU间----CPUTIME、
进程阻塞间STARTBLOCK-表示进程运行STARTBLOCK间片进程进入阻塞状态
进程阻塞间BLOCKTIME--表示进程阻塞BLOCKTIME间片进程进入绪状态
进程状态—STATE
队列指针NEXT 用PCB排队列
3、调度原则：
进程优先数及需要运行间事先指定（由随机数产）进程达间进程输入间
进程运行间间片单位进行计算
进程绪队列待间片优先数加1
每进程状态绪 R（READY）、运行R（Run）阻塞B(BLOCK)、或完F（Finish）四种状态
绪进程获 CPU都能运行间片用已占用CPU间加1表示
运行间片进程已占用CPU间已达所需要运行间则撤消该进程运行间片进程已占用CPU间未达所需要运行间进程需要继续运行应进程优先数减3插入绪队列等待CPU
每进行调度程序都打印运行进程、绪队列、及各进程 PCB便进行检查
重复程直所要进程都完止
求课程设计报告用c语言编写源代码
Ⅳ 求一个操作系统课程设计
#include<iostream>
using namespace std;
#define MAX 10
struct task_struct
{
char name[10]; /*进程名称*/
int number; /*进程编号*/
float come_time; /*到达时间*/
float run_begin_time; /*开始运行时间*/
float run_time; /*运行时间*/
float run_end_time; /*运行结束时间*/
int priority; /*优先级*/
int order; /*运行次序*/
int run_flag; /*调度标志*/
}tasks[MAX];
int counter; /*实际进程个数*/
int fcfs(); /*先来先服务*/
int ps(); /*优先级调度*/
int sjf(); /*短作业优先*/
int hrrn(); /*响应比高优先*/
int pinput(); /*进程参数输入*/
int poutput(); /*调度结果输出*/
void main()
{ int option;
pinput();
printf("请选择调度算法（0~4）:\n");
printf("1.先来先服务\n");
printf("2.优先级调度\n");
printf(" 3.短作业优先\n");
printf(" 4.响应比高优先\n");
printf(" 0.退出\n");
scanf("%d",&option);
switch (option)
{ case 0:
printf("运行结束。\n");
break;
case 1:
printf("对进程按先来先服务调度。\n\n");
fcfs();
poutput();
break;
case 2:
printf("对进程按优先级调度。\n\n");
ps();
poutput();
break;
case 3:
printf("对进程按短作业优先调度。\n\n");
sjf();
poutput();
break;
case 4:
printf("对进程按响应比高优先调度。\n\n");
hrrn();
poutput();
break;
}
}
int fcfs() /*先来先服务*/
{
float time_temp=0;
int i;
int number_schel;
time_temp=tasks[0].come_time;
for(i=0;i<counter;i++)
{
tasks[i].run_begin_time=time_temp;
tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;
tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time;
number_schel=i;
tasks[number_schel].order=i+1;
}
return 0;
}
int ps() /*优先级调度*/
{
float temp_time=0;
int i=0,j;
int number_schel,temp_counter;
int max_priority;
max_priority=tasks[i].priority;
j=1;
while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].priority>tasks[i].priority)
{
max_priority=tasks[j].priority;
i=j;
}
j++;
} /*查找第一个被调度的进程*/
/*对第一个被调度的进程求相应的参数*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
max_priority=0;
for(j=0;j<counter;j++)
{ if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if (tasks[j].priority>max_priority)
{
max_priority=tasks[j].priority;
number_schel=j;
}
} /*查找下一个被调度的进程*/
/*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}
int sjf() /*短作业优先*/
{
float temp_time=0;
int i=0,j;
int number_schel,temp_counter;
float run_time;
run_time=tasks[i].run_time;
j=1;
while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].run_time<tasks[i].run_time)
{
run_time=tasks[j].run_time;
i=j;
}
j++;
} /*查找第一个被调度的进程*/
/*对第一个被调度的进程求相应的参数*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
for(j=0;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
}
for(j=0;j<counter;j++)
{ if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if(tasks[j].run_time<run_time)
{run_time=tasks[j].run_time;
number_schel=j;
}
}
/*查找下一个被调度的进程*/
/*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}
int hrrn() /*响应比高优先*/
{ int j,number_schel,temp_counter;
float temp_time,respond_rate,max_respond_rate;
/*第一个进程被调度*/
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
/*调度其他进程*/
while(temp_counter<counter)
{
max_respond_rate=0;
for(j=1;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{ respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time;
if (respond_rate>max_respond_rate)
{
max_respond_rate=respond_rate;
number_schel=j;
}
}
} /*找响应比高的进程*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].run_flag=1;
temp_counter+=1;
tasks[number_schel].order=temp_counter;
}
return 0;
}
int pinput() /*进程参数输入*/
{ int i;
printf("please input the process counter:\n");
scanf("%d",&counter);
for(i=0;i<counter;i++)
{ printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the name:\n");
scanf("%s",tasks[i].name);
printf("please input the number:\n");
scanf("%d",&tasks[i].number);
printf("please input the come_time:\n");
scanf("%f",&tasks[i].come_time);
printf("please input the run_time:\n");
scanf("%f",&tasks[i].run_time);
printf("please input the priority:\n");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0;
}
return 0;
}
int poutput() /*调度结果输出*/
{
int i;
float turn_round_time=0,f1,w=0;
printf("name number come_time run_time run_begin_time run_end_time priority order turn_round_time\n");
for(i=0;i<counter;i++)
{
f1=tasks[i].run_end_time-tasks[i].come_time;
turn_round_time+=f1;
w+=(f1/tasks[i].run_time);
printf(" %s, %d, %5.3f, %5.3f, %5.3f, %5.3f, %d, %d, %5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1);
}
printf("average_turn_round_timer=%5.2f\n",turn_round_time/counter);
printf("weight_average_turn_round_timer=%5.2f\n",w/counter);
return 0;
}
如果对您有帮助，请记得采纳为满意答案，谢谢！祝您生活愉快！
Ⅳ 操作系统课程设计 （包括进程管理、进程的同步和互斥、存储管理）
- 课程设计的计算机操作系统程序
课程概述
计算机操作系统是中央广播电视大学计算机科学与技术专业（本科），系统设置必修课程。教学总时数72.4学分，开设一学期。前课程，计算机组成原理，面向对象编程和数据结构。
计算机操作系统课程是计算机专业的课程，通过学习，使学生掌握电脑作业系统的设计和组成的基本原则之一;计算机操作系统的基本概念和新的概念，术语和术语;了解计算机的发展，操作系统的功能和设计技巧和方法，基本操作使用最常用的计算机操作系统（DOS，Windows，UNIX或Linux）的。
？课程内容
主要内容包括：概述电脑的操作系统，作业管理，文件管理，存储管理，输入输出设备管理，工艺和管理处理器，操作系统结构和编程。
二，系统的教学内容和教学要求
章概述操作系统的中
教学内容：
操作系统的定义和发展形成的操作系统和五个主要类型，操作系统五大功能特性的操作系统的性能，配置的操作系统，“生成”的概念
教学要求：
主：什么是操作系统;知道五类和五功能的操作系统;
至少掌握：掌握操作系统的安装，使用和维护的实际怀抱;
理解：如何理解一个初步的了解，熟悉和解剖学的人机交互界面的操作系统
任务的作业管理
教学内容如下：
的特点，人机界面的发展;操作系统的shell语言的第一，第二和第三代接口的发展特点，基本键盘命令和系统调用任务调度算法; 教学要求：
主的人机界面设计
大师：掌握基本的作业系统人机界面的设计思路;
理解：传统的接口界面
章文件管理的
教学内容：
文件管理任务和功能的操作系统文件的结构和分类的物理结构和逻辑结构的文件，文件目录结构，文件访问控制和安全机制，文件系统模型结构;
教学要求：
水平：基本的文件访问控制和系统管理;
>掌握的文件系统目录分类管理功能;
理解：文件系统的程序设计
的章内部存储管理
教学内容：
内存分区，分页，子段的管理理念;物理地址和逻辑地址内存“扩展”技术;存储管理，支柱存储管理的内存分配算法的
教学的要求：
掌握基本配置：内存管理和调度方法;
主：主不同的分区存储管理，分页和分段方法;
有关：有效利用的内存空间
第五章输入和输出设备管理器的教学内容：
的输入和输出设备的功能分类;独占的，共享的，虚拟装置的管理功能;输入和输出设备的处理程序;管理策略的输入和输出设备;
教学要求：
法师：法师的输入和输出设备的管理特性;
法师：法师分类设计方法的输入和输出设备;
明白了：
编程元素的输入和输出设备处理程序第
教学内容的低级别的处理器管理：
操作系统的核心功能，“过程”的概念，过程的并发和并行的基本状态的转换的过程;进程调度算法进程同步和互斥过程PV操作，“锁”的概念;
教学要求：
大师：在操作系统内核运行的基本概念“过程“;
掌握的基本转换过程中的状态和特征;
理解：操作系统
教学内容，进程调度算法的编程方案的结构
BR />第七章：
操作分层的模块化的系统结构设计和操作系统的测试;的
教学的要求：
本章教学基本要求：了解基本的设计思路和方法现代计算机操作系统
三，教学媒体
本课程使用的教学媒体：文字材料，视频材料，网络教学和辅导。
1。文字材料
计算机操作系统（2）武企业万元清华大学出版社
注：本课程实验的主要教材。
文字教材过程中的主要传播媒介。准备的文字材料，同时保持先进性，科学的学科体系，这两种作业系统的理论，技术，实现了一体化的三个强调的能力。
2。视频教材
该课程16节和视频，每讲50分钟，讲授的课程集中困难，科目汇总。为了帮助学生理解操作系统的整体概念和思想，伍启元教授扬声器。
当然，视频与相应的文字材料，注重艺术表达播放视频教材，教学形象化。
3。
在线教学网上教学和指导，咨询与上述有机介质方面的作用：（1）释放的教学和指导性文件，课程公告，咨询，参考材料;（2）根据工程进度教学，心理咨询聊天室发表的一篇文章“自我测试题（3）实时Q＆A，一天到一天的课程论坛Q;（4）开展网上教师培训与教学研讨会。
文字材料的基础上，对学生的学习，视频教科书的补充文字材料，在线咨询是一个方便的教学和学习方式的互动。总之，分工和各种媒体，让学生有更大的自主学习空间，以方便学生自由选择，自主学习，提高学生的自我学习能力。
教学安排建议
当然主要教科书和课程实验教学安排建议
教学点，请根据中央电大统一安排课程，面对面辅导的要求，如表1所示。
表1的主要教科书和课程实验教学安排建议
每周教学内容小时的实验内容推荐小时
操作系统的教学安排概述
2操作系统定义了五种类型， 5 4
三人人机界面管理Linux的实践准备1
四个工作管理任务调度4
五个文件管理的任务和功能的Linux操作系统命令的逻辑结构和物理结构4
7个存储管理任务和功能2命令解释器4
九编制2
八分分配存储管理段4
分配的存储管理作业调度模拟编程的六个文件10设备管理的任务和职能
11种设备，技术和管理存储分配管理设计4
过程的定义和特征4 13进程调度和通信进程调度模拟编程 p> 15操作系统级模块结构僵局的产生和处理14 26 4
（总复习）4
共56条16
课程视频内容，示于表2。
章教学内容表2视频教材课程小时的视频时间分配
操作系统提供了一个概述8小时4
运营管理8小时2
文件管理2
8小时的存储管理8小时
5个设备管理器
6过程管理8小时10小时4
7操作系统的系统程序结构6小时0
56小时16
2在线咨询在线咨询内容
包括教学文件，课程辅导，网络教室。充分利用网络资源，和偶尔的在线课程相关的辅导材料，定期，根据教学在线辅导和考试Q＆A活动，适当安排的需要。具体安排如下：
？
包括课程介绍，教师，教学大纲，教学设计，教学档案。
？课程辅导
包括课程学习和答案，专题辅导，习题和答案，自我测试，评估说明，网上还提供了教师讲课教案教学点的教学使用。
？网络课堂
包括直播课堂和IP课件。
基于网络的教学活动：中央广播电视大学一般集中在每学期安排的实时在线辅导学生，教师的教学和研究活动。具体的时间表，每学期上发布的TVU的网上家园。
？论坛：每天的日常应答的过程中。
课程的课堂直播第一学期，通过教育电视台播出，安排四次直播课堂，每次50分钟。的第一堂课3个教学点，难点的教学和演讲后代表咨询审查的辅导和考试说明的过程中反映的共性问题。直播课堂挂在网页上的内容。
工作
课程形成性评估书，当然工作量。工作成绩计入课程成绩。中央电大的工作，不时抽查，检查审查和完成作业。
课程考试，请参阅“中央广播电视大学计算机操作系统课程评估的指示。建议
五，教学方法？教学建议
（1）计算机操作系统是一个实用的课程。其特点是概念多，涉及范围广。要求教学辅导深和混乱的概念来进行详细说明，并详细描述每章的重点，管理和控制的调度算法技能。
（2）注重培养学生熟悉的操作系统，以及在维护操作系统的问题进行分析，并在实验中解决问题的能力。
？建议
（1）从宏观和微观把握学习操作系统。在宏观上，要认识到在计算机系统中的操作系统的地位清除操作系统的整体结构;微观方面应把握的操作系统是管理计算机资源（过程中，处理器，内存，文件，设备），了解概念，原理和技术。
（2）操作系统是计算机技术和管理技术相结合的联想日常生活学习重复熟悉的样品管理实现运营系统的管理方法，以加深对问题的理解。
（3）要注意加强自我学习的能力，有能力实现这一目标的“学习”的文化。
Ⅵ 操作系统课程设计 （包括进程管理、进程的同步和互斥、存储管理）
一、实验的目的与基本要求实验目的本课程设计是为了配合操作系统课程的理论教学而设置的，目的是通过课程设计的综合训练，加强学生对操作系统概念的实际应用技能的训练，提高学生分析问题和解决问题的能力。基本要求课程设计按照教学要求需要两周时间完成，两周中每天（按每周5天）至少要上3-4小时的机来调试程序。学生要发挥自主学习的能力，充分利用时间，安排好课设的时间计划，并在课设过程中不断检测自己的计划完成情况，及时的向教师汇报。课程设计的具体内容如下：设计1 进程管理1. 设计目的加深对进程概念的理解，明确进程和程序的区别；进一步认识并发执行的实质；实现Linux中进程通信的两种方式：软中断和管道通信。2. 设计内容1) 进程的创建和控制编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。每个进程在屏幕上显示一个字符，记录屏幕上的显示结果，并分析原因。修改以编写的程序，将每个进程输出一个字符改为每个进程输出一句话。2) 进程的软中断通信使用系统调用fork()创建两个子进程，使用系统调用signal（）让父进程捕捉用alarm函数设置时钟的时间段终止时产生的信号，当捕捉到该信号后，父进程使用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出子进程被杀死信息后终止，父进程等待两个子进程终止后，输出父进程被杀死信息后终止程序。记录屏幕上的显示结果，并分析原因。3) 进程的管道通信使用系统调用pipe()建立一个管道；两个子进程分别向管道写信息，父进程则从管道读出来自子进程的信息，显示在屏幕上。记录屏幕上的显示结果，并分析原因。3. 系统调用函数说明、参数值及定义1. Fork()创建一个新进程进程int fork()其中返回int取值意义如下：正确返回：在父进程中返回子进程的进程号，在子进程中返回0错误返回：-12. Lockf(int files,int function,long size)用作锁定文件的某些段或者整个文件。file：文件描述符；function：锁定和解锁，1表示锁定，0表示解锁；size：是锁定或解锁的字节数，若用0，表示从文件的当前位置到文件尾。3. Signal(int sig, (*func) function)进程控制软中断信号的处理。signal()会依照参数sig指定的信号编号来设置该信号的处理函数。sig： SIGALRM: alarm()函数设置的时钟的时间段终止时产生的信号.其它信号略function：信号处理的一个函数地址。4. kill(int pid,int sig)向一个进程或一个进程组发信号，可以用来送参数sig指定的信号给参数pid指定的进程。pid: pid>0 将信号传给进程号为pid的进程其它略signumber: 送给进程号为pid进程指定信号量5. alarm(unsigned int seconds)设置一个指定时间的计时器seconds: 设置时间秒数6. int pipe(int filedes[2])filedes为整数数组名,在调用这个函数后,系统为通道分配的两个文件描述符将通过这个数组返回到用户进程中, filedes[1]是文件输出描述符, filedes[0]是文件输入描述符7. int wait(int *status)暂停目前进程的执行，直到有信号到来或子进程的结束。子进程的结束状态指会由参数status返回，如果不在意结束状态时，则参数status可以设置成NULL设计2 进程的同步与互斥1. 设计目的分析进程争用资源的现象，学习解决进程互斥的方法。2. 设计内容用程序实现生产者-消费者问题l 问题描述： 一个仓库可以存放K件物品。生产者每生产一件产品，将产品放入仓库，仓库满了就停止生产。消费者每次从仓库中去一件物品，然后进行消费，仓库空时就停止消费。l 数据结构：进程：Procer - 生产者进程，Consumer - 消费者进程 buffer: array [0..k-1] of integer; in,out: 0..k-1; in记录第一个空缓冲区，out记录第一个不空的缓冲区 s1,s2,mutex: semaphore; s1控制缓冲区不满,s2控制缓冲区不空,mutex保护临界区； 初始化s1=k,s2=0,mutex=1l 原语描述procer（生产者进程）： Item_Type item;{while (true){proce(&item);p(s1);p(mutex);buffer[in]:=item; in:=(in+1) mod k;v(mutex);v(s2);}}consumer（消费者进程）： out:=(out+1) mod k;v(mutex);v(s1);}}设计3 存储管理1. 设计目的通过请求页式存储管理中页面置换算法设计，了解存储技术的特点，掌握请求页式存储管理的页面置换算法。2. 设计内容l 将指令序列转换为用户虚存中的请求调用页面流。i. 页面大小为1Kii. 用户内存容量为4页到40页iii. 用户外存的容量为40k在用户外存中，按每K存放10条指令，400条指令在外存中的存放方式为：0-9条指令为第0页10-19条指令为第1页。390-399条指令为第39页按以上方式，用户指令可组成40页l 通过随机数产生一个指令序列，共400个指令（0-399）l 模拟请求页式存储管理中页面置换算法执行一条指令，首先在外存中查找所对应的页面和页面号，然后将此页面调入内存中，模拟并计算下列各述算法在不同内存容量下的命中率(页面有效次数/页面流的个数)1) 先进先出的算法(FIFO)2) 最久未使用算法(LRU)3. 提示l 随机指令的产生 rand() 或srand()l 用户内存中页面控制结构采用链表 页面控制结构 struct p_str{ int pagenum; /* 页号 */ int count; /* 访问页面的次数 */struct p_str next; /* 下一指针 */}p_str;
Ⅶ 求操作系统课程设计
没有兴趣帮你做，太浪费时间了。
工作量和回报不相符合。
去VB那里看看吧！可能有人有已经制作好的！
Ⅷ 跪求操作系统课程设计一份
; boot.asm: ANOS fat12 软盘启动代码
; Larry Li, 2005.2.25
; 2005.3.19
; 整理注释
PosBuf equ 0700h
StackTop equ 07BF0h
BootStart equ 07C00h
;下面是内核的加载地址
SegKernel equ 0100h
RootBufEnd equ 02h
DataStart equ 04h
CursorPos equ 10h
; BOOT 会被 BIOS 载入到 00007C00h 处
org 7C00h
; 代码段
segment .text
; 16 位代码
bits 16
; start: 首先是跳过必须的 FAT 信息表执行后面的程序
Start:
jmp short Main
; 补一个字节的空指令
nop
; FAT12 信息
; 只是文件系统的描述信息
OEMName db 'ANOSDISK'
; 扇区大小（字节），应为 512
BytesPerSector dw 512
; 簇的扇区数，应为 2 的幂，FAT12 为 1
SectsPerCluster db 1
; 保留扇区，FAT12/16 应为 1
ReservedSectors dw 1
; FAT 结构数目，一般为 2
NumberOfFats db 2
; 根目录项目数，FAT12 为 224
MaxRootEntries dw 224
; 扇区总数，1.44M 软盘为 2880
TotalSectors dw 2880
; 设备类型，1.44M 软盘为 F0h
MediaDescriptor db 0f0h
; FAT 占用扇区数，9
SectorsPerFat dw 9
; 磁道扇区数，18
SectorsPerTrack dw 18
; 磁头数，2
NumberOfHeads dw 2
; 隐藏扇区，默认为 0
HiddenSectors dd 0
; FAT32 使用，0
TotalSectorsBig dd 0
;; 下面的内容为 FAT12/16 所有，和 FAT32 不同
; MS-DOS 使用，0
BootDrive db 0
; Windows NT 使用，0
Reserved db 0
; 附加的可启动标志，29h
ExtendSig db 029h
; 卷标序列号，00000000h
SerialNumber dd 00000000h
; 卷标，11 字节，必须用空格( 20h )补齐
VolumeLabel db 'ANOS FLOPPY'
; 文件系统标志，
FileSystem db 'FAT12 '
; Main: BOOT 主程序
Main:
; 初始化运行环境
xor ax,ax
mov ss,ax
mov bp,BootStart
mov sp,StackTop
push ss
pop ds
; LoadRootDirSector: 读取 FAT12 根目录项目扇区
LoadRootDirSector:
push ss
pop es
; 计算 ROOT 启始逻辑扇区
mov al,[BYTE bp+NumberOfFats]
; FAT 表数目
mul WORD [BYTE bp+SectorsPerFat]
; 乘上一个 FAT 表占用的扇区数
add ax,WORD [BYTE bp+HiddenSectors]
; 加上隐藏的扇区数
add ax,WORD [BYTE bp+ReservedSectors]
; 加上保留的扇区数
push ax
mov WORD [BYTE bp-DataStart],ax
; AX ROOT 项目的启始逻辑扇区, 保存
; 计算 ROOT 扇区数
mov ax,20h
mov cx,WORD [BYTE bp+MaxRootEntries]
mul cx
mov bx,WORD [BYTE bp+BytesPerSector]
add ax,bx
dec ax
div bx
mov cx,ax
; CX ROOT 扇区大小
add WORD [BYTE bp-DataStart],ax
; 更新数据区启始逻辑扇区
mul bx
; AX ROOT 总扇区字节大小
mov bx,PosBuf
; BX 缓存启始地址
add ax,bx
; AX 缓存尾地址
mov WORD [BYTE bp-RootBufEnd],ax
; 保存尾地址
pop ax
; 取出 ROOT 项目启始逻辑扇区
call ReadSectors
mov si,bx
; [ES:SI] 根目录内容
; SearchRootDirSector: 在根目录项目中搜索内核文件
SearchRootDirSector:
; [ES:SI] 为当前目录项
; 其头 11 个字节为文件名称
cmp [es:di],ch
; 如果目录项的第一个字节是0，这就是最后一个目录项
jz NotFound
push si
; 保存 SI rep cmpsb 时 SI 会改变
mov cx,11
; 比较前 11 个字节
mov di,FileName
; [DS:DI] 要载入的内核名称
rep cmpsb
; 比较 [ES:SI] [DS:DI]
pop si
; 恢复 [ES:SI] 为当前查对的目录项
je FoundKernel
add si,32
; [ES:SI] 指向下一个目录项
; 每个目录项 32 字节
cmp si,WORD [BYTE bp-RootBufEnd]
; 是否到根目录项目尾
jb SearchRootDirSector
; NotFound: 没有发现内核的处理
NotFound:
mov si,msgNotFound
call PutChars
jmp ReBoot
; FoundKernel: 发现内核后处理
FoundKernel:
; [ES:SI] 内核文件目录项
mov ax,[si+01ah]
push ax
; 内核文件启始簇(低)地址
; 目录项偏移 26(1ah) 为文件项目启始簇低地址
; 偏移 20(14h) 为高地址
; 由 FAT12 只是 12 位簇地址, 低地址 16 位足以
xor dx,dx
mov es,dx
mov ax,WORD [BYTE bp+ReservedSectors]
; DX:AX 第一个 FAT 表的启始逻辑扇区
mov bx,PosBuf
; [ES:BX] 读盘缓存
mov cx,WORD [BYTE bp+SectorsPerFat]
; CX FAT 表扇区数
call ReadSectors
pusha
mov si,msgLoadKernel
call PutChars
popa
mov ax,SegKernel
mov es,ax
xor bx,bx
; [ES:BX] 读盘缓存, 内核载入地址
pop ax
push ax
; 文件的第一个簇
; LoadKernel: 载入内核
LoadKernel:
; AX 当前簇
call ReadCluster
pop ax
; 取当前簇
add bx,0200h
; [ES:BX] 缓存地址增加 512 字节(1 个扇区)
; 下面开始查 FAT12 表项目
; 所以对于簇 n 其项目位于 n / 2 * 3 处
; n / 2 * 3 = n / 2 + n
; n 为偶, 在低 12 位
; n 为奇, 在高 12 位
mov di,ax
; BP DI 文件簇 n
shr di,01h
; DI n / 2
pushf
; 保存标志位, 供以后奇偶处理
add di,ax
; DI n / 2 + n
add di,PosBuf
; DI 加上 FAT12 表的启始地址
mov ax,[di]
; AX 一个 FAT12 组, 两个簇号
popf
; 根据 n / 2 奇偶判定
jc ShiftRight4
and ax,0fffh
; 取低 12 位
jmp IsTheEnd
ShiftRight4:
mov cl,4
shr ax,cl
; 高 12 位, 所以右移 4 位
IsTheEnd:
cmp ax,0ff8h
; 比较, ff8h - fffh 表示簇链末尾
jae ExecKernel
; 载入完毕, 跳转到内核地址
push ax
; 复制下一簇号
jmp LoadKernel
; ExecKernel: 运行内核
ExecKernel:
pusha
mov si,msgLoadKernelOK
call PutChars
popa
mov ah,3
xor bh,bh
int 10h
mov WORD [BYTE bp-CursorPos],dx
; 将当前光标位置写入 7df0h 7df1h
;
push word SegKernel
push word 00h
; 入栈供返回指令跳转
retf
; BadDisk: 显示错误启动信息，然后重启
BadDisk:
mov si,msgDiskError
call PutChars
; ReBoot: 重启
ReBoot:
mov si,msgAnyKey
call PutChars
xor ax,ax
int 16h
; 等待键盘按键
int 19h
; 重启
; ReadCluster: 读磁盘文件簇
; 读数据簇 AX 到 [ES:BX]
; CarryFlag == 1 错误
ReadCluster:
; 显示一个 .
push ax
mov ax,0e2eh
int 10h
pop ax
dec ax
dec ax
; 修正, 簇号 - 2
add ax, WORD [BYTE bp-DataStart]
; AX 数据的启始逻辑扇区
xor dx,dx
mov cx,01h
; ReadSectors: 读磁盘扇区
; 读 CX 个逻辑扇区(地址 DX:AX)到 [ES:BX]
; CarryFlag == 1 错误
ReadSectors:
pusha
push cx ; 保存读取扇区数
; 首先要将 DX:AX 逻辑扇区号转换为[驱动器号][磁头号][磁道号][扇区号]
; 根据：磁盘总扇区 = 磁道数 * 磁头数 * 扇区数
; 逻辑扇区 = (磁道号 * 磁头数 + 磁头号) * 扇区数 + 扇区号 - 1
; （注意：实际在磁道的扇区号是从 1 开始计数的，其他号从 0 开始）
; 那么：扇区号 = 逻辑扇区 % 磁道的扇区数 + 1
; 同样：含磁头计算的磁道号 = 逻辑扇区 / 磁道的扇区数
; 除掉磁头数，就是：磁道号 = 含磁头计算的磁道号 / 磁头数
; 所以：磁头号 = 含磁头计算的磁道号 % 磁头数
xchg ax,cx ; AX <=> CX
xchg ax,dx ; AX <=> DX
; AX:CX 逻辑扇区
xor dx,dx ; DX 清零
div WORD [BYTE bp+SectorsPerTrack] ; 除高位
; 计算得含磁头计算的磁道号的高位
xchg ax,cx ; 临时保存到 CX
; 此时余数 DX 与 AX 组成新数继续低位除
div WORD [BYTE bp+SectorsPerTrack] ; 除低位
; 余数 DX 为 0 开的扇区号
inc dx ; 修正为 1 开
xchg cx,dx ; CX <=> DX
; CX 为扇区号
; DX:AX 为含磁头计算的磁道号
div WORD [BYTE bp+NumberOfHeads] ; 继续除
; AX 为磁道号
; DX(DL) 为磁头号
mov dh,dl
; DH 磁头号
mov dl,[BYTE bp+BootDrive]
; DL 驱动器号
mov ch,al
; CX bit 8-15(CH) 磁道低 8 位
ror ah,2
; CX bit 6-7(AH bit 6-7) 磁道高 2 位
or cl,ah
; CX bit 0-5 扇区
pop ax
; AL 操作扇区数目
mov ah,02h
; AH 02h 读磁盘扇区
int 13h
; BIOS 13h 调用
; int 13h BIOS 功能
; 参数
; AH = 0x02 读磁盘扇区到内存
; AL 需要读出的扇区数量
; CH 磁道(柱面)号的低 8 位
; CL 开始扇区(0-5位)，磁道号高 2 位(6-7)
; DH 磁头号
; DL 驱动器号
; ES:BX 指向数据缓存
; 返回
; 出错置 CF 标志位
; AH 状态 = 0x01
; AL 读取的扇区数
jc BadDisk
popa
ret
; PutChars: 打印字符串
; 入口参数 si
PutChars:
lodsb
or al,al
jz short Done
mov ah,0eh
mov bx,07h
int 10h
jmp short PutChars
Done:
retn
TheEnd:
db 0
msgLoadKernel db 'Loading ANOS',0
msgLoadKernelOK db 'OK!',0Dh,0Ah,0
msgNotFound db 'Cannot found ANOS kernel!',0Dh,0Ah,0
msgDiskError db 'Disk Error!',0Dh,0Ah,0
msgAnyKey db 'Press any key to reboot...',0Dh,0Ah,0
; 将 BOOT 映象对齐到 512 个字节
times 496-($-$$) db 0
FileName db 'ANOS SYS',0,0
BootPartition:
db 0
; 启动标志
BootSignature dw 0AA55h ; BootSector signature
Ⅸ 操作系统课程设计
设计题目
1设计题目：CPU调度(CPU调度算法的模拟实现)
具体内容：编写算法，实现CPU调度算法FCFS、非抢占SJF、可抢占优先权调度、RR
针对模拟进程，利用CPU调度算法进行调度
进行算法评价，计算平均周转时间和平均等待时间
要求：调度所需的进程参数由输入产生
手工输入
随机数产生
输出调度结果
输出鸡掸惯赶甙非轨石憨将算法评价指标
2设计题目：虚拟内存 (页面置换算法的模拟实现)
具体内容：编写算法，实现页面置换算法FIFO、LRU
针对内存地址引用串，运行页面置换算法进行页面置换
要求：算法所需的引用串参数由输入产生：可由手工输入也可基于随机数产生
输出内存驻留的页面集合
1．进程调度算法模块
[问题描述]
1、进程调度算法：采用动态最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。
2、每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：
进程名---进程标示数 ID
优先数 PRIORITY 优先数越大优先权越高
到达时间---进程的到达时间为进程输入的时间。、
进程还需要运行时间ALLTIME，进程运行完毕ALLTIME=0，
已用CPU时间----CPUTIME、
进程的阻塞时间STARTBLOCK-表示当进程在运行STARTBLOCK个时间片后，进程将进入阻塞状态
进程的阻塞时间BLOCKTIME--表示当进程阻塞BLOCKTIME个时间片后，进程将进入就绪状态
进程状态—STATE
队列指针NEXT 用来将PCB排成队列。
3、调度原则：
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
进程在就绪队列中待一个时间片，优先数加1
每个进程的状态可以是就绪 R（READY）、运行R（Run）阻塞B(BLOCK)、或完成F（Finish）四种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减3，然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
求课程设计报告和用c语言编写的源代码
Ⅹ 操作系统课程设计
这里有许多操作系统的课程内容和课件,有的演示程序比较生动,希望对你的课有帮助:
http://www.ccec.e.cn/xxjs/jsjx/jpk/os/1.htm
http://oa.gt.e.cn/os/multimedia/learn.htm
http://jpkc.cuit.e.cn/kecheng/czxt/contentshow.asp?classid=51&class=1