操作系統含課程設計
Ⅰ 我的操作系統課程設計,希望高手給解答一下
下面是我們實驗的材料，你可以看一下，基本一樣，只要把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