『壹』 跪求操作系統帝！！關於一個SJF演算法的問題！！
非搶占式SJF演算法
0時刻A執行，3個時間，周轉時間3.
3時刻B等了1個時間，而C還沒到執行B，6個時間，到達時間按9，周轉時間7.
9時刻CDE都到了等待。E的工作時間最短，執行E，2個時間到達11，周轉時間3.
11時刻CD在等待。C需求時間短，C執行，4個時間，到達15，周轉時間11.
15時刻D執行，5個時間，到達20整個完成，周轉時間是14.
平均周轉時間=(3+7+3+11+14)/5=7.6
帶權平均周轉時間=（3/3+7/6+3/2+11/4+14/5）/5=1.84
『貳』 關於學習c語言的問題
他說的沒錯 這本說的確很好 我也在學習這半書
我這里有點筆記是高手們學習c語言留下的 我想也許對你會有用
C程序入門
第一講 語言的分類
一。低級語言：計算機語言,採用二進制進行編程，用戶難度大，機器易識別。
二。匯編語言：（低級語言）採用簡單的英文字母進行編程，用戶稍意識別，計算機不能使被識別，需翻譯。
匯編程序：將匯編語言譯成機器語言。
反匯編語言：將機器語言譯成匯編語言。
三。高級語言∶採用近於自然語言進行編程，用戶易編程，計算機不能識別，需翻譯，速度慢。
解釋程序：整句翻譯；
編譯程序：整個程序翻譯；
二，C語言的特點
1，C語言是一門中級語言
低級語言：直接訪問硬體
高級語言：自然語言移植性較好
2，C是一門結構化程序設計語言
有屬性，循環性，選擇性
3，C有豐富的數據類型和運算符
數據類型：數據在計算機內的表現形式
基本數據類型：整型 實型 字元型
int float char
控制符：
%d 整型
%f 實型
%c 字元型
4，C語言的結束符為分號大括弧為一個語句或函數范圍
5，C語言的構成
#include<文件名。h>
#define 宏名 字元
main 主函數
①預處理（以#開頭) (不屬於C語言)
②書寫主函數（。C）
一個C語言程序是與主函數構成，主函數有且只有一個，main。
可以有或沒有子函數
執行程序
從子函數開始從左到右，從上倒下。
補充：
數制
一。含義
由一組數組成且按照一定的規則對數據進行管理的制度
二。分類
二進制 八進 十 十六
組成：
二：0 1
八：0--7
十：0--9
十六：0--9和a--f
權：根據位置不同，所表示的數值不同。表示：基數的n次冪（n從0開始）
基數：組成該數制的數字個數。
123
1*100+2*10+3*1
三。轉換
1。十制數-->其它進制
規則：
整數：除以相應數制的基數然後除余倒排列。
小數：乘以相應數制的基數然後除整數正排列。
**當乘不盡時,保留前兩位.
(13.5）10=(1101.1)2
2.其它進制-->十制數
規則:按權展開,相加求和.
(1101.167)8=(13.)10
3.其它進制
二<--->八
採用421演算法
(001 011 011 010 101 110.001 101 011 100)2=(133256.1534)8
規則:從小數點開始向兩側每三個二進制位為一組,不足3位的,整數部分在前面補齊,小數部分在後面補齊,然後,對每一組按權展開相加求和.
八-->二
採用421反演算法
將一個八進制位拆分3個二進制位.
(75462.5041)8=(111101100110010.101000100001)2
二-->十六
採用8421演算法
規則:從小數點開始向兩側每四個二進制位為一組,不足4位的,整數部分在前面補齊,小數部分在後面補齊,然後,對每一組按權展開相加求和.
(1001 1110 1110 1100 1010.1101 1001 0100)2=(9eca)16
十六-->二
採用8421反演算法
將一個十六進制位拆分4個二進制位.
(10afd)16=(10000101011111101)2
八<--->十六
藉助二,十進制
第二講 數據類型 常量 變數
一.數據類型:
數據在計算機內的表現形式
整型
基本數據 單精度
實型(浮點型)
雙精度
字元型
結構體
構造類型 共用體
數組
指針型,空類型.
二.常量
<一>.含義,在程序招待過程中,其值不變的量.
<二>.使用形式
1.字面量.
s=2*P*r;
2.宏符號
#define X 3.141592627
int x;
<三>分類
整型常量 實型常量 字元型常量 字元串常量
A:整型常量
1.表示形式
八進制 十進制 十六進制(二進制不能表示整型常量)
2.書寫格式
十進制:由0--9組成,不能以0開頭.5 6
八進制:由0--7組成,必須以0開頭.eg:05 07
十六進制:由0--9和a--f組成,必須以0x開頭. 0x5 0xa 0xa01
3.分類,范圍,空間,控制符
十進制:
-5 1111111111111111
5 0000000000000101
123
0 1 999
有符號 (signed) int x; %d -32768----32767
短整型(2B)
無符號 unsigned int x; %u 0----65535
有符號 (signed) long (int) x; %ld -2147483648----2147483647
長整型(4B)
無符號 unsigned long (int) x; %lu 0-----429......
八進制(無符號)
符合整數的定義規則 .
短無(2B): %o 0---0177777
長無(4B):%lo 0---037777777777
十進制(無符號)
符合整數的定義規則 .
短無(2B): %x 0---0xffff
長無(4B):%lx 0---0xffffffff
B:實型常量
1。表示形式
十進制 指數形式
2.十進制
由0--9組成,必須有小數點,小數點前面或後面有數據.
單精度:float %f 10(-38)----10(38) 4B
雙精度:double %lf 10(-308)---10(308) 8B
3.指數形式
階碼標志:E(e)代表10
double x=1.23457e+3;
必須有階碼標志E(e),階碼標志前和後必須有數據,且前面是整數或實數,指數部分:必須是整數.
%e 與%f一致小數點後保留6位,且E也算一位
C:字元型常量
1.書寫格式
由一對單引號括起的任意一個字元.
2.分類
ASCII碼字元(共256個)
'a'---'z'[97--122] 'A'--'Z'[65--90] '0'---'9' [48--57]
ASCII碼值:每個字元對應的十進制整數.(無符號) 0---255
main(){ char c; scanf("%c",&c); printf("%c",c-32);}
if(c>=97&&c<=122)
printf("%c is xiaoxie",c);
else if(c>='A'&&c<='Z')
printf("%c is da xie",c);
else if(c>='0'&&c<=57)
printf("%c is shuzi",c);
else
printf("%c is qita",c);
轉義字元
書寫格式:以\開頭,用一對單引號括起一個或多個字元,但是表示是一個字元.
分類:
'\+字母':作用:主要控制游標.
'\n':游標回車換行.
'\t':游標跳到下一個製表位
'\r':游標回到行首
'\b':游標左退一列
printf("******\n*******");
'\+標點':作用:控制輸出一個標點符號
'\'':輸出一個單引號
'\"':輸出一個雙引號
'\\':輸出一個反斜杠
'\+數字': 作用:表示一個ASCII碼字元.
'\0ddd':八進制轉義字元:最多三位八進制數*****0可以省略.
'\xdd':十六進制轉義字元:最多二位十六進制數
'\0123' '\123'
'\xa1'
printf("%c",'\61');
3.范圍(1B)
有符號:-128----127
無符號:0--255
char c=-5;
printf("%c",c);
D：字元串常量
書寫格式：由一對雙引號括起任意零個1個或多個字元。
字元串的長度：組成該字元串的字元個數。
字元串結束標志：'\0'
空間:串長度+1個空間.
控制:%s
char x[100];
scanf("%s",x);
printf("%s",x);
printf("%s","kdfjlkdsjfsdls");
printf("%s","zheng");
"":空串.
三.變數
1.其值在執行程序中可以改變的量.
2.定義格式
存儲類型 數據類型 變數名1,變數名2,......變數名n;
int x,y,z;
存儲類型:變數開辟空間的類型.
auto:(默認)自動型 該變數的默認值為隨機值.
static:靜態型 該變數的默認值為0值.
regiester:寄存器型 該變數的默認值為隨機值.
extern:外部參照型 該變數的默認值為0值. (我們使用省略extern型)
static int x;
printf("%d",x);
aaa.prg
a1.c int x;
a2.c extern int x;
a3.c
int x;
main()
{
int x;
}
變數名:
a:多個變數之間用,隔開;
b:相同類型的變數可以寫在同一個語句中;
int a,b,c;
c:變數命名
必須符合合法的用戶標識符
標識符:用來表明或表示變數或函數的名字或類型的符號.
關鍵字:用來標識類型的標識符.(32個關鍵)
存儲類型,數據類型,流程類 ,運算符類(sizeof)
標識符:由字母,數字,下劃線組成,不能以數字開頭,不能與關鍵字重名.
int if;
_a1;
1a
a 1;
main()
{
int x,X;
float x;
****不能與同一范圍內的變數名重名.*****
3.給變數賦值.
通過兩種:
賦值表達式: =
輸入函數:scanf()
x=3;
scanf("%d",&x);
a:賦值表達式
格式: 變數名=表達式;
左邊必須是變數名,右邊賦值給左邊,並將左邊變數的值覆蓋.當一個變數進行多次賦值時,該變數只能保留最一次所賦的值.
main()
{
int x;
x=2;
x=5;
scanf("%d",&x);
printf("%d",x);
getch();
}
int x,y,z;
x=2;
y=3;
z=x;
x=y;
y=z;
x=3;
y=2;
b:scanf()
格式:scanf("控制符",地址項)
scanf("%d%f%c",&x,&y,&z);
3. 數據類型之間轉換(兩個自動,一個強制)
a:在賦值時,右邊數據的類型自動轉換成左邊變數的類型.
int x;
x=1.23;
float x;
x=10;
char c=65;
int x='a';
int x=32768;
printf("%d,%u",x,x);
b:運算時,數據類型低的轉換成數據類型高的(占空間的位元組數)
int x;
float y;
printf("%f ",x+y);
c:強制轉換
格式:(數據類型)表達式
數據類型:將要轉換成的類型
表達式:要轉換的對象.
(float)x+y
(float)(x+y)
x+(float)y
float x=12.345,y;
y=x-(int)x;
printf("%f",x);
(int)x%2==0
第三講 運算符及表達式
目:根據運算對象對運算符分為:單目,雙目,三目.
表達式:簡單和復雜表達式
簡單:無運算連接的式子. 3 x (1)
復雜:有運算連接的式子. x+y x=3 x<y
一.算術運算符 +(正)-(負)+ - / * %
規則:
/ :當運算對象都為整數時,結果取整的.若其中一個為實型,結果為實型. 1/2.
%(取余/模):要求:運算對象必須為整型.
int x,y;
x%y
x=123
x%10;
x/10%10
x/100
表達式
式子的類型:與運算對象中占空間最大的一致.
優先順序:正,負-->*/%-->+,-
結合性:單目:從右向左;雙目:從左向右.
- - -5
x%2/y*z
二.賦值運算符 = += -= /= *= %=(自反賦值)
規則: s=5
自反賦值:左邊和右邊先按指定的運算符進行運算,然後再賦值給自己.*****左邊必須先有值.
x=2;
x+=5
x=x+5;
表達式:
表達式的值與左邊變數的值一致.
printf("%d",x=5);
結合性:從右向左
int x=3;
x+=x-=1;
三.關系運算符 < > <= >= == !=
規則:.
表達式的值:邏輯值,當判斷成立時,得到邏輯值真值(用1表示),不成立時,得到邏輯值假值(用0表示)****因為C語言中沒有邏輯型數據****
類型:整型.
int x,y;
x=3;
y=4;
printf("%d ",x<y);
c<='z'&&c>='a' 'z'>=x>='a'
優先順序:< > <= >= -->== !=
結合性:從左向右
x>y>z x>y && x>z
四.邏輯運算符 &&(邏輯與) 雙目 ||(邏輯或) 雙目 !(邏輯非）單目
規則:
格式:表達式1&&/||表達式2
&&:表達式1和表達式2必須都為真值(非零值),整個邏輯與表達式才成立.產生邏輯值真值(用1表示)
如果表達式1或表達式2其中一個是假值(0值),整個邏輯與表達式不成立.產生邏輯值假值(用0表示)
x= x=5&&6<9;
||:表達式1或表達式2成立,則整個式子成立,產生真值(用1表示).若兩個式子都為假值,整個邏輯或表達式為假(用0表示)
x>='a'||x<='z'
!:格式: !表達式
當表達式為真(非零值)值,邏輯非表達式為假(用0表示)
當表達式為假(零值)值,邏輯非表達式為真(用1表示)
x=!(4>5)
優先順序:!-->&&-->||
x>='a'&&x<='z' || x>='A'&&x<='Z'
*********
&&:如果表達式1為假了,系統不對表達式2進行計算了
||:如果表達式1為真了,系統不對表達式2進行計算了
int x,y;
x=3;
y=4;
x= x<y&&!5;
x,y?
x=x>y||x=9
x,y?
對&&和||而言:不是按優先順序計算,而是先計算表達式1,再計算表達式2.
結合性:單目:從右向左
雙目:從左向右
! ! ! ! !5
表達式的值:邏輯值
類型:整型.
int x,y;
scanf("%
if(x>y)
五。自增/減運算符 ++ -- 單目
規則：
表達式++ 表達式-- 後綴表達式
++表達式 --表達式 前綴表達式
main()
{
int x;
x=2;
printf("%d",x++);
x=2;
printf("%d",++x);
}
變數的值：會自動的增/減1；
表達式的值：
後綴表達式：與變數改變之前值一致。
前綴表達式：會與變數的值一致增/減1；
表達式：
x++ x=x+1 x+=1
六。條件運算符( ? : )三目
規則：
表達式1？表達式2：表達式3
x>y?printf("%d",x):pritnf("%d",y);
int x,y;
w=x>y?x:y;
printf("%d",w);
int x,y;
if(x>y)
printf("%d",x);
else
printf("%d",y);
先計算表達式1，若產生非零值，則執行表達式2，並將表達式2的值作為整個條件表達式的值，若產生
零值，則執行表達式3，並將表達式3的值作為整個條件表達式的值(若執行表達式2，不執行表達式3）
int x,y,w;
x=5;
y=4;
w=x>y?x++:y++;
printf("%d,%d,%d",w,x,y);
if(x>y)
x++;
else
y++;
x,y?
優先順序:
單目(++,--,-+!)-->算術雙目-->關系-->邏輯運算-->條件-->賦值->逗號.
結合性:從右向左分出正確的表達式,從左向右計算.
?: ? ?: : ? :
w=x>y? x>z?x: z : y>z?y: z
3個
w,x,y,z
if(x>y)
if(x>z)
w=x;
else
w=z;
else
if(y>z)
w=y;
else
w=z;
七.逗號 , 雙目
作用:分隔,運算符
格式:表達式1,表達式2
規則:從左向右算,取最後一個表達式的值為整個逗號表達式的值.
int x=5,y;
y=x++,--x,x,x+1,x;
x,x+1,x,(y=x++,++x);
y=(x++,--x,x,x+1,x);
printf("%d",(x,y));
第四講 流程式控制制語句
順序 循環 選擇
一.選擇語句
if..else 和 switch
作用:根據條件執行程序的某一部分.
A:if...else
1.格式
if(條件表達式)
{
語句組1;
}
else
{
語句組2;
}
注意:
a:if,else為關鍵字必須為小寫.
b:條件表達式:一般寫關系或邏輯表達式.
c:else可選項,{}當執行語句只有一句時,可以省略.
2.執行過程
首先計算條件表達式的值,若為非零值,則執行if分支,否則,若有else分支,則執行else,沒有時,執行下面的其它語句.
3.嵌套
在if或else分支中又出現if..else語句.
a:在else中出現if..else
if( )
.....
else if( )
.....
else if( )
.....
else
......
b:在if分支中出現if...else
if1( )
if2( )
if3( )
if4( )
.....
else4
.....
else3
.....
else2
......
else1
........
c:在if和else中出現if...else
if( )
if( )
....
else
....
else
if( )
....
else
....
if(x%4==0&&x%100!=0||x%400==0)
if(x%4==0)
if(x%100==0)
if(x%400==0)
printf("run");
else
printf("ping");
else
run;
else
ping
if(x>y)
if(x>z)
w=x;
else
w=z;
else
if(y>z)
w=y;
else
w=z;
B:多開關語句switch
格式
switch(表達式)
{
case 常量表達式1:語句組1;[break;]
case 常量表達式2:語句組2;[break;]
case 常量表達式3:語句組3;[break;]
................n:.....n;[break;]
default :語句組n+1;
}
注意:
a:表達式的類型必須與常量表達式的類型一致.整型或字元型.
b: break;是可選項, 當遇到break表示該語句執行完畢.
c:default是可選項.{}不可省略.
d:同一個switch語句中,常量表達式的值不能重復.
int x,y;
char w;
scanf("%d%d%c",&x,&y,&w);
switch(w)
{
case '+':printf("%d",x+y);break;
case '*':printf("%d",x*y);break;
case '/':printf("%d",x/y);break;
case '-':printf("%d",x-y);break;
default:printf("wu ci yun suan fu");
}
2.執行過程
......
3.嵌套.
char c;
scanf("%c",&c);
switch(c>='a'&&c<='z')
{
case 0:switch(c>='A'&&c<='Z')
{
case 0:switch(c>='0'&&c<='9')
{
case 0:printf("qita");break;
case 1:pritnf("shuzi");break;
}break;
case 1:printf("daxie");break;
}break;
case 1:printf("xiaoxie");break;
}
二.循環語句
for while do...while
作用:根據條件重復執行程序的某一部分.
A:for語句
1.格式
for(表達式1;表達式2;表達式3)
{
循環體語句;
}
for(x=1;x<=10000;x++)
{
printf("%d",x);
}
注意:
a:表達式1:給循環變數賦初值
b:表達式2:決定是否應該進入循環的條件,一般為關系或邏輯表達式.
c:表達式3:給變數重新賦值.
d:{}可以省略.3個表達式均可省略.同時省略 for(;;)無限循環.
2.執行過程
首先執行表達式1給變數賦初值,然後再判斷表達式2是否成立.若成立則進入循環體,當執行到}表示一次循環體執行完畢.再執行表達式3給變數賦新值,然後再判斷表達式2是否成立.若成
立,再進入循環體,否則,表示該語句執行完畢.
1.求1---100和
2.接收10個實數,對小數部分求和.
B:while語句
a.格式
while(表達式)
{
循環體;
}
注意:{}當循環體只有一句時,可以省略.表達式與表達式2一樣,但不能省略.while(1)===for(;;)無限循環.
for(i=1;i<=100;i++)
printf("%d",i);
int i;
i=1;
while(i<=100)
{
printf("%d",i++);
}
補充:
輸入/出單個字元的函數.**必須預處理<stdio.h>
getchar()和putchar()
格式
變數名=getchar();
putchar(變數名/常量);
main()
{
char x;
scanf("%c",&x);
printf("%c",x);
x=getchar();
putchar(x);
}
C.do ...while
a:格式
do
{
循環體;
}while(表達式);
注意:
;{}均不可省略.先執行一次循環體,再判斷表達式是否成立.
至少執行一次.
main()
{
int i;
i=1;
do
{
printf("%d",i);
}while(++i<=100);
D:嵌套
for(i=1;i<=3;i++)
for(j=1;j<=3;j++)
for(k=0;k<=59;k++)
{
printf("%d:%d:%d",i,j,k);
delay(1);
}
****
***
**
*
for(i=1;i<=4;i++)
{
for(j=1;j<=5-i;j++)
printf("*");
putchar('/n');
}
1!+2!+3!+4!+....n!
階乘。
三.轉移
break;
作用：只能用在循環體或switch語句中。
用在循環體中，為了終止其所在的循環體。
while(c!='*')
c=getchar();
if(c=='*')
break;
continue;
只能用在循環體中，提前結束本次循環體語句，而進入下一次循環體。
for(i=1;i<=100;i++)
{
if(i%2)
continue;
printf("%d",i);
}
***********************************************
數組前的筆記
+qq619740933，能幫你講得盡量幫你講明白
『叄』 急求 程序代碼 c/c++ 操作系統中的 處理機調度演算法
#include <iostream>
#include <stdio.h>
#include <string>
//#include <windows.h>
using namespace std;
//hyugtyftydrtdtrdrrtrdrt
struct Node
{
string name;//進程（作業）名稱
int arriveTime;//到達時間
int ServerTime;//服務時間
int leftTime;//the left time
Node *link;//指向下一個節點的指針
};
class CProcess
{
public:
CProcess();//構造函數
~CProcess();//析構函數
const CProcess &operator =(const CProcess& p);//重載賦值操作符
void insertNode(string &na,int& at,int& st);//插入新元素（at由小到大）到鏈表合適的位置
void sort();//按照服務時間由大到小排序
bool isEmpty();//判斷是否為空
void destroy();//銷毀
int length();//求出鏈表長度
void print();//列印出元素
void FCFS();//先到先服務
void SJF();//短進程(作業)優先
void RR(int& q);//時間片輪轉
void priority();//優先權調度
protected:
Node *first;
Node *last;
};
const CProcess& CProcess::operator=(const CProcess& p)
{
Node *newNode;
Node *Current;
if(this!=&p)//避免自己給自己賦值
{
if(first!=NULL)//如果鏈表不為空
destroy();
if(p.first==NULL)
{//如果要拷貝的對象為空
this->first = NULL;
this->last = NULL;
}
else
{
Current = p.first;
first= new Node;
first->name=Current->name;//
first->arriveTime=Current->arriveTime;
first->ServerTime=Current->ServerTime;
first->link =NULL;
last =first;
Current = Current->link;
while(Current!=NULL)
{
newNode = new Node;
newNode->name=Current->name;
newNode->arriveTime=Current->arriveTime;
newNode->ServerTime=Current->ServerTime;
newNode->link=NULL;
last->link=newNode;
last=newNode;
Current = Current->link;
}
}
}
return *this;
}
CProcess::CProcess()
{//構造函數
first=NULL;
last=NULL;
}
CProcess::~CProcess()
{
Node *temp;
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::insertNode(string &na,int& at,int& st)
{//按照到達時間升序排序
Node *Current;
Node *trailCurrent;//指向Current的前一個節點
Node *newNode;
bool found;
newNode = new Node;//建立一個新節點
newNode->name=na;
newNode->arriveTime=at;
newNode->ServerTime=st;
newNode->link=NULL;//
if(first==NULL)//如果第一個節點為空（如果是第一次插入元素）
first=newNode;//將新節點賦給第一個節點
else
{//如果不是第一次
Current =first;
found = false;
while(Current!=NULL && !found)
{
if(Current->arriveTime >= at)
found = true;
else
{
trailCurrent = Current;
Current = Current->link;
}
}
if(Current==first)
{
newNode->link = first;
first = newNode;
}
else
{
trailCurrent->link = newNode;
newNode->link = Current;
}
}
}
int CProcess::length()
{
int count =0;//聲明變數，並初始化為0（用來記錄長度）
Node *Current;
Current = first;
while(Current!=NULL)//當前節點不為空，記錄值自加，一直向後遍歷,
{
count++;
Current = Current->link;
}
return count;//返回長度
}
void CProcess::sort()//按照服務時間，升序排列
{//冒泡排序
string sname;
int at;
int st;
Node *Current;//指向當前節點
Node *trailCurrent;//指向當前節點的前一個節點
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制條件有問題
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制條件有問題
{
if(trailCurrent->ServerTime > Current->ServerTime)
{
sname=trailCurrent->name;
at=trailCurrent->arriveTime;
st=trailCurrent->ServerTime;
trailCurrent->name=Current->name;
trailCurrent->arriveTime=Current->arriveTime;
trailCurrent->ServerTime=Current->ServerTime;
Current->name=sname;
Current->arriveTime=at;
Current->ServerTime=st;
}
}
}
}
bool CProcess::isEmpty()//判斷是否為空
{
return (first==NULL);//如果第一個節點為空，返回值
}
void CProcess::print()
{
Node *Current;
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)//當前節點不為空，一直向後遍歷列印
{
cout<<Current->name<<" ";
cout<<Current->arriveTime<<" ";
cout<<Current->ServerTime<<"\n";
Current = Current->link;
}
}
void CProcess::destroy()
{
Node *temp;//定義一個臨時指針變數
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::FCFS()//先到先服務
{
Node *Current;
int T0=0;//完成時間
int T1=0;//周轉時間
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周轉時間等於，完成時間 - 到達時間
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
}
}
void CProcess::SJF()//短進程(作業)優先
{
//首先執行第一個到達的作業
Node *Current;
int T0=0;//完成時間
int T1=0;//周轉時間
T0=first->link->ServerTime+T0;
T1=T0-first->link->arriveTime;
cout<<first->link->name<<"\t";
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
first->link=first->link->link;//刪除
//執行剩下的
sort();//對剩下的排序
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周轉時間等於，完成時間 - 到達時間
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
}
}
void CProcess::RR(int& q)//時間片輪轉
{
cout<<"時間片輪轉操作完成！\n";
}
void CProcess::priority()//優先權調度
{
cout<<"優先權操作完成！\n";
}
void main()
{
CProcess p0,p1,p2,p3,p4;
int at,st;
string na;
int judge=1;//控制退出程序
int choice;//控制選擇操作
while(judge)
{
cout<<"********************************************************\n";
cout<<"****** 說明：本程序適用於單道進程（作業） ******\n";
cout<<"******** 請選擇您的操作 ***************\n";
cout<<"*********輸入相應的數字，按下（Enter）鍵！**************\n";
cout<<"************* 5.錄入信息 ************\n";
cout<<"************* 1.先到先服務 ************\n";
cout<<"************* 2.短進程（作業）優先 ************\n";
cout<<"************* 3.時間片輪轉 ************\n";
cout<<"************* 4.優先權(靜態)調度 ************\n";
cout<<"************* 0.退出程序 ************\n";
cout<<"********************************************************\n";
cin>>choice;
switch(choice)
{
case 0:
judge=0;
break;
case 5:
cout<<"請輸入信息以「end」結束輸入！\n";
cout<<"進程名 到達時間 服務時間"<<endl;
while(na.compare("end"))//如果相等則會返回0
{
p0.insertNode(na,at,st);
cin>>na>>at>>st;
}
cout<<"錄入成功，目前的信息為：\n";
cout<<"進程名 到達時間 服務時間"<<endl;
p0.print();
break;
case 1://先到先服務
p1=p0;//拷貝一份
if(p1.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"先到先服務\n";
cout<<"進程名 完成時間 周轉時間\n";
p1.FCFS();
break;
}
case 2://短作業優先
p2=p0;//拷貝一份
//p2.sort();
//p2.print();
if(p2.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"短作業優先\n";
cout<<"進程名 完成時間 周轉時間\n";
p2.SJF();
break;
}
case 3://時間片輪轉
p3=p0;//拷貝一份
int q;
if(p3.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"請輸入時間片大小";
cin>>q;
cout<<"時間片輪轉\n";
cout<<"進程名 完成時間 周轉時間\n";
p3.RR(q);
break;
}
case 4://優先權
p4=p0;//拷貝一份
if(p4.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"時間片輪轉\n";
cout<<"進程名 完成時間 周轉時間\n";
p4.priority();
break;
}
default:
cout<<"請選擇目錄中的選項！\n";
break;
}
}
return;
}
『肆』 求c語言程序，500行左右，要有詳細注釋。
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
typedef struct JOB
{
int hour;//用於存儲輸入的時
int min;//用於存儲輸入的分
int ID;//記錄此作業的號
int requesttime;//存儲作業所估計運行時間
int runtime;//作業周轉時間
int cometime;//作業進入時間
int finishtime;//作業結束時間
int starttime;//作業開始時間
float runtime2;//帶權周轉時間
int prior;//響應比
}JOB;
float counttime1=0;//用於存儲總的周轉時間
float counttime2=0;//用於存儲總的帶權周轉時間
int nowtime;
int flat=0;
int sign=0;
void insert(JOB [],JOB);
void FCFS();
void SJF();
void HRN();
void getprior(JOB a,int b);
int getmin(int i);
int gethour(int i);
int trans(int i,int j);
#define N 100
JOB job[N];
JOB wait[N];//用於SJF中存儲等待的作業的時間
JOB job2[N];//由於在SJF中不好控制輸出時按照作業序號的順序輸出，用一個數組存儲
int co=0;
int jobnum;
void main()
{
int i;
printf("輸入作業數：\n");
scanf("%d",&i);
jobnum=i;
FILE *fp;
fp = fopen("in.txt","rb");
if(fp == NULL)
{
printf("Can't open in.txt");
exit(0);
}
for(int j=0;j<i;j++)
{
fscanf(fp,"%d:%d %d",&job[j].hour,&job[j].min,&job[j].requesttime);
job[j].ID=j+1;
job[j].cometime=job[j].hour*60 + job[j].min;
printf("%d\n",job[j].requesttime);
}
printf("\n ================================");
printf("\n | 1:FCFS 2:SJF |");
printf("\n | 3:HRN |");
printf("\n ================================");
printf("\nPlease select a number from (1,2,3):");
scanf("%d",&i);
switch(i)
{
case 1: FCFS();break;
case 2: SJF();break;
case 3: HRN();break;
}
}
void FCFS()
{
printf("\n\n根據先來先服務演算法：\n");
int k;
for(int i=0;i<jobnum-1;i++)//將作業數組按照進入時間先後排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].cometime<job[k].cometime) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
for(int i=0;i<jobnum;i++)
{
if(i==0)//如果是第一個任務
{
job[i].starttime=job[i].cometime;
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
}
else
{
job[i].starttime=(job[i-1].finishtime>job[i].cometime ? job[i-1].finishtime : job[i].cometime);
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
}
}
printf("作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
FILE *fp;
fp = fopen("FCFS.txt","w");
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n");
exit(0);
}
fprintf(fp,"作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
for(int i=0;i<jobnum-1;i++)//將作業數組按照作業的ID排序
{
k=i;
for(int j=i+1;j<jobnum;j++)
if(job[j].ID<job[k].ID)
k=j;
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
for(int i=0;i<jobnum;i++)
{
int a,b,c,d;
a=gethour(job[i].starttime);
b=getmin(job[i].starttime);
c=gethour(job[i].finishtime);
d=getmin(job[i].finishtime);
printf("JOB%d ",job[i].ID);
fprintf(fp,"JOB%d ",job[i].ID);
if(job[i].min==0)
{
printf("%d:%d0 ",job[i].hour,job[i].min);
fprintf(fp,"%d:%d0 ",job[i].hour,job[i].min);
}
else
{
printf("%d:%d ",job[i].hour,job[i].min);
fprintf(fp,"%d:%d ",job[i].hour,job[i].min);
}
printf("%11d ",job[i].requesttime);
fprintf(fp,"%11d ",job[i].requesttime);
if(b==0)
{
printf("%d:%d0 ",a,b);
fprintf(fp,"%d:%d0 ",a,b);
}
else
{
printf("%d:%d ",a,b);
fprintf(fp,"%d:%d ",a,b);
}
if(d==0){
printf("%d:%d0 ",c,d);
fprintf(fp,"%d:%d0 ",c,d);
}
else{
printf("%d:%d ",c,d);
fprintf(fp,"%d:%d ",c,d);
}
printf("%11d%11f\n",job[i].runtime,job[i].runtime2);
fprintf(fp,"%13d%13f\n",job[i].runtime,job[i].runtime2);
}
printf("【平均周轉周期為:%f】\n【平均帶權周轉時間：%f】",(float)counttime1/jobnum,counttime2/jobnum);
fprintf(fp,"【平均周轉周期為:%f】\n【平均帶權周轉時間：%f】",(float)counttime1/jobnum,counttime2/jobnum);
system("pause");
}
int trans(int i,int j)
{
return i*60 + j;
}
int gethour(int i)
{
return i/60;
}
int getmin(int i)
{
return i%60;
}
void SJF()
{
printf("\n\n根據短作業優先演算法：\n");
int k;
for(int i=0;i<jobnum-1;i++)//將作業數組按照進入時間先後排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].cometime<job[k].cometime) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
int numbers=jobnum;
int realnum=jobnum;
for(int i=0;i<numbers;i++)
{
if(i==0)//假如是第一個，則直接進入cpu進行作業
{
job[i].starttime=job[i].cometime;
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime;
nowtime=job[i].finishtime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
job2[co++]=job[i];
for(int u=0;u<jobnum-1;u++)//把第一個從job序列的移除
job[u]=job[u+1];
jobnum--;
int j=0;
while(job[j].cometime<=nowtime&&j<jobnum)//從剩餘的job序列中獲取正在等待的job，放進wait序列中
{
wait[flat++]=job[j++];
}
int i=0;
if(j!=0)//j!=0則表明已經從job序列中轉移了job到wait序列中
{
while(j<jobnum)//將已經轉移的job從job序列中移除
{
job[i]=job[j];
i++;
j++;
}
jobnum=i;
}
if(flat>1)//如果wait序列中不止一個等待作業
{
int r;
for(int x=0;x<flat-1;x++)//將等待數組按照估計運行時間先後排序。
{
r=x;
for(int y=x+1;y<flat;y++)
{
if(wait[y].requesttime<wait[r].requesttime)
r=y;
}
if(r!=x)
{
JOB a;
a=wait[r];
wait[r]=wait[x];
wait[x]=a;
}
}
}
}
else
{
if(flat==0)//如果wait序列中沒有，即沒有等待的序列，則將job序列中的第一個作業放入cpu進行運行
{
job[0].starttime=job[0].cometime;
job[0].finishtime=job[0].starttime+job[0].requesttime;
job[0].runtime=job[0].finishtime-job[0].cometime;
job[0].runtime2=(float)job[0].runtime/(float)job[0].requesttime;
nowtime=job[0].finishtime;
counttime1+=job[0].runtime;
counttime2+=job[0].runtime2;
job2[co++]=job[0];
for(int u=0;u<jobnum-1;u++)//將放入運行的作業從job序列中移除
job[u]=job[u+1];
jobnum--;
int j=0;
while(job[j].cometime<=nowtime&&j<jobnum)//從剩餘的job序列中獲取正在等待的job，放進wait序列中
{
wait[flat++]=job[j++];
}
int i=0;
if(j!=0)//j!=0則表明已經從job序列中轉移了job到wait序列中
{
while(j<jobnum)
{
job[i]=job[j];
i++;
j++;
}
jobnum=j;
}
int r;
if(flat>1)//如果wait序列中不止一個等待作業
{
for(int x=0;x<flat-1;x++)//將等待數組按照估計運行時間先後排序。
{
r=x;
for(int y=x+1;y<flat;y++)
{
if(wait[y].requesttime<wait[r].requesttime) r=y;
}
if(r!=x)
{
JOB a;
a=wait[r];
wait[r]=wait[x];
wait[x]=a;
}
}
}
}
else//否則如果wait序列中有等待作業，則調用wait序列的第一個作業
{
wait[0].starttime=nowtime;
wait[0].finishtime=nowtime+wait[0].requesttime;
wait[0].runtime=wait[0].finishtime-wait[0].cometime;
wait[0].runtime2=(float)(wait[0].runtime)/(float)(wait[0].requesttime);
nowtime=wait[0].finishtime;
counttime1+=wait[0].runtime;
counttime2+=wait[0].runtime2;
job2[co++]=wait[0];
for(int i=0;i<flat;i++)//將wait序列的第一個作業從wait中移除
wait[i]=wait[i+1];
flat--;
int j=0;
while(job[j].cometime<=nowtime&&j<jobnum)//從剩餘的job序列中獲取正在等待的job，放進wait序列中
{
wait[flat++]=job[j++];
}
int i=0;
if(j!=0)//j!=0則表明已經從job序列中轉移了job到wait序列中
{
if(j==1&&jobnum==1)//job序列中最後一個作業已經轉移到wait中，則將jobnum自減一到0
jobnum--;
else
{
while(j<jobnum)//否則將已轉移的作業從job中移除
{
job[i]=job[j];
i++;
j++;
}
jobnum=j;
}
}
int r;
if(flat>1)//如果wait里的等待序列多餘一個，則進行重新排序
{
for(int x=0;x<flat-1;x++)//將等待數組按照估計運行時間先後排序。
{
r=x;
for(int y=x+1;y<flat;y++)
{
if(wait[y].requesttime<wait[r].requesttime)
r=y;
}
if(r!=x)
{
JOB a;
a=wait[r];
wait[r]=wait[x];
wait[x]=a;
}
}
}
}
}
}
printf("作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
FILE *fp;
fp = fopen("SJF.txt","w");
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n");
exit(0);
}
fprintf(fp,"作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
for(int i=0;i<realnum-1;i++)//將作業數組按照作業的ID排序
{
k=i;
for(int j=i+1;j<realnum;j++)
if(job2[j].ID<job2[k].ID)
k=j;
if(k!=i)
{
JOB a;
a=job2[k];
job2[k]=job2[i];
job2[i]=a;
}
}
for(int i=0;i<realnum;i++)
{
int a,b,c,d;
a=gethour(job2[i].starttime);
b=getmin(job2[i].starttime);
c=gethour(job2[i].finishtime);
d=getmin(job2[i].finishtime);
printf("JOB%d ",job2[i].ID);
fprintf(fp,"JOB%d ",job2[i].ID);
if(job2[i].min==0)
{
printf("%d:%d0 ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d0 ",job2[i].hour,job2[i].min);
}
else
{
printf("%d:%d ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d ",job2[i].hour,job2[i].min);
}
printf("%11d ",job2[i].requesttime);
fprintf(fp,"%11d ",job2[i].requesttime);
if(b==0)
{
printf("%d:%d0 ",a,b);
fprintf(fp,"%d:%d0 ",a,b);
}
else
{
printf("%d:%d ",a,b);
fprintf(fp,"%d:%d ",a,b);
}
if(d==0){
printf("%d:%d0 ",c,d);
fprintf(fp,"%d:%d0 ",c,d);
}
else{
printf("%d:%d ",c,d);
fprintf(fp,"%d:%d ",c,d);
}
printf("%11d%11f\n",job2[i].runtime,job2[i].runtime2);
fprintf(fp,"%13d%13f\n",job2[i].runtime,job2[i].runtime2);
}
printf("【平均周轉周期為:%f】\n【平均帶權周轉時間：%f】",(float)counttime1/realnum,counttime2/realnum);
fprintf(fp,"【平均周轉周期為:%f】\n【平均帶權周轉時間：%f】",(float)counttime1/realnum,counttime2/realnum);
system("pause");
}
void HRN()
{
co=0;
printf("\n\n根據最高響應比優先演算法：\n");
int k;
for(int i=0;i<jobnum-1;i++)//將作業數組按照進入時間先後排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].cometime<job[k].cometime) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
nowtime=job[0].cometime;
for(int i=0;i<jobnum;i++)
{
int j=i;
int xx=i;
while(j++<jobnum)//依次求得未完成的作業的優先順序
job[j].prior=1+(float)(nowtime-job[j].cometime)/job[j].requesttime;
int k;
for(int i=xx;i<jobnum-1;i++)//將作業數組按照響應比由高到低排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].prior>job[k].prior) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
if(job[i].prior>=1)//有等待的則讓等待的開始時間等於現在時間
job[i].starttime=nowtime;
else
job[i].starttime=job[i].cometime;//沒有等待的作業的話就讓下一次第一個進入的工作的時間當作其開始時間並且賦給當前時間
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/job[i].requesttime;
nowtime=job[i].finishtime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
job2[co++]=job[i];
}
printf("作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
FILE *fp;
fp = fopen("HRN.txt","w");
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n");
exit(0);
}
fprintf(fp,"作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
for(int i=0;i<jobnum-1;i++)//將作業數組按照作業的ID排序
{
k=i;
for(int j=i+1;j<jobnum;j++)
if(job2[j].ID<job2[k].ID)
k=j;
if(k!=i)
{
JOB a;
a=job2[k];
job2[k]=job2[i];
job2[i]=a;
}
}
for(int i=0;i<jobnum;i++)
{
int a,b,c,d;
a=gethour(job2[i].starttime);
b=getmin(job2[i].starttime);
c=gethour(job2[i].finishtime);
d=getmin(job2[i].finishtime);
printf("JOB%d ",job2[i].ID);
fprintf(fp,"JOB%d ",job2[i].ID);
if(job2[i].min==0)
{
printf("%d:%d0 ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d0 ",job2[i].hour,job2[i].min);
}
else
{
printf("%d:%d ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d ",job2[i].hour,job2[i].min);
}
printf("%11d ",job2[i].requesttime);
fprintf(fp,"%11d ",job2[i].requesttime);
if(b==0)
{
printf("%d:%d0 ",a,b);
fprintf(fp,"%d:%d0 ",a,b);
}
else
{
printf("%d:%d ",a,b);
fprintf(fp,"%d:%d ",a,b);
}
if(d==0){
printf("%d:%d0 ",c,d);
fprintf(fp,"%d:%d0 ",c,d);
}
else{
printf("%d:%d ",c,d);
fprintf(fp,"%d:%d ",c,d);
}
printf("%11d%11f\n",job2[i].runtime,job2[i].runtime2);
fprintf(fp,"%13d%13f\n",job2[i].runtime,job2[i].runtime2);
}
printf("【平均周轉周期為:%f】\n【平均帶權周轉時間：%f】",(float)counttime1/jobnum,counttime2/jobnum);
fprintf(fp,"【平均周轉周期為:%f】\n【平均帶權周轉時間：%f】",(float)counttime1/jobnum,counttime2/jobnum);
system("pause");
}
作業調度
『伍』 操作系統問題
一：
答：操作系統是計算機發展的必然產物。
從1950年至今，操作系統的發展主要經歷了如下幾個階段：
1. 手工操作階段-------無操作系統；
2. 批處理系統---------早期批處理、執行系統；
3. 操作系統形成---------批處理操作系統、分時操作系統、實時操作系統；
4. 現代操作系統---------個人計算機操作系統、網路操作系統、分布式操作系統
它是由客觀的需要而產生，並隨著計算機技術的發展和計算機應用的日益廣泛而逐漸發展和完善的。它的功能由弱到強，在計算機中的地位也不斷提高，以至成為系統的核心。研究操作系統的發展歷程是用一種歷史的觀點去分析操作系統，總結操作系統從無到有，直到現代操作系統，經歷了幾個階段，每個階段採用的技術、獲得的成就、解決的問題以及進一步發展出現的新問題，都便於從中體會操作系統產生的必然性。
二：
答：1：操作系統是一個大型的程序系統，它負責計算機系統軟，硬體資源的分配和管理；控制和協調並發活動；提供用戶介面，是用戶獲得良好的工作環境。
2：操作系統是重要的系統軟體，只有配置了操作系統這一系統軟體後，才使計算機系統體現出系統的完整性和可利用性。
三：
答：
批處理：引入批量監督程序是為了實現作業建立和作業過渡的自動化。監督程序是一個常駐主寸很小的核心代碼；隨著處理機速度的不斷提高，處理機和I/O設備之間的速度差距形成了一對矛盾；為了克服這一缺點，在批處理系統中引入了離線I/O技術而形成了離線批處理系統。
批處理系統是在解決人機矛盾，中央處理器高速度和I/O設備的低速度這一矛盾的過程中發展起來的。
執行系統：藉助於通道與中斷技術，I/O工作可以在主機控制之下完成。這時，原有的監督程序不僅要負責調度過夜自動地運行，而且還要提供I/O控制功能，它增強了原有的功能。執行系統比拖機處理前進了一步，它節省了衛星機，降低了成本，而且同樣能支持主機和通道，主機和外設的並行操作。在執行系統中用戶程序的I/O工作是委託給系統實現的，由系統檢查其命令的合法性，這就可以避免由於不合法的I/O命令造成對系統的威脅，從而提高系統的安全性，。
四：
答(1)多道：即計算機內存中同時年放幾道相互獨立的程序。
(2)寵觀亡並行：同時進入系統的幾進程序都處於運行過程中．即它們光後開始了各自
的運行，但都未運行完畢。
(3)微觀上串列；從`微觀上看，主寸中的多道程序輪流或分時地佔有處理機，交替執行。
分時技術：（1調制性：即眾害聯機用戶可以同時使用一台計算機；
2：由於配置的分時操作系統是採用時間片輪轉的辦法使一台計算機同時為許多終端用戶服務的。因此，客觀效果是這地用戶彼此之間都感覺不到別人也在使用這台汁計算機．好象只有自己獨占計算機一樣，所以分時系統響應比較快。
五：
答：網路操作系統要求網路用戶在使用網路資源時首先必須了解網路資源，網路用戶必須知道網路中各個計算機的功能與配置、軟體資源、網路文件結構等情況，在網路中如果用戶要讀一個共享文件時，用戶必須知道這個文件放在哪一台計算機的哪一個目錄下；分布式操作系統是以全局方式管理系統資源的，它可以為用戶任意調度網路資源，並且調度過程是「透明」的。
六：教材26頁第七題
（2）cpu有空閑等待現象，在程序b輸入結束後，程序a還未輸入，造成等待現象。
（3）運行是沒有等待現象，因為系統有一個輸入機兩個列印機，所以沒有等待現象。
七：
答：處理機的態就是處理機當前處於何種狀態，正在執行哪種程序。為了保護操作系統，至少要區分兩種狀態：管態和用戶態。
用戶程序運行時，所需資源必須向操作系統提出請求，自己不能隨意取用系統資源，這兩類不同的程序（管理程序和用戶程序）執行時應有不同的許可權，為此根據對資源和機器指令的使用許可權，將處理執行時的工作狀態區分為不同的狀態。
八：
答：中斷是指某個時間發生時，系統終止現行程序的運行，引出處理時間程序對該事件進行處理，處理完畢後返回斷點，繼續執行。為了實現並發活動，為了實現計算機的自動化工作，系統必須具備處理中斷能力。
九：
答：強迫性中斷是由某種事故或外部請求信號所引起的，而自願中斷是由於運行程序請求操作系統服務而引起的，強迫性中斷則不是。（I/O，外中斷，機器故障中斷，程序性中斷屬於強迫中斷，而訪問管理中斷是屬於自願中斷。中斷是處理機外部事件引起的中斷，俘獲則是處理機內部引起的中斷。在同時發生中斷和俘獲請求時，俘獲總是優先得到響應和處理的。（UNIX系統中的中斷和俘獲及處理機制在小型機和微型機中具有代表性。）整個中斷處理的功能是由硬體和軟體配合完成的，硬體負責中斷進入過程即發現和響應中斷請求，把中斷原因和斷點記下來供軟體處理查用，同時負責引出中斷處理程序。而中斷分析，中斷處理，恢復被中斷程序現場等工作則由軟體的中斷處理程序來完成。
十：
答：中斷源：引起中斷的事件是中斷源。
中斷裝置：確保後繼指令能正確執行的那些現場狀態信息。
中斷響應：實質是指交換指令執行地址的處理器狀態，以達到保留程序斷點及有關信息；並自動轉入相應的中斷處理程序執行。
向量中斷：當中斷發生時，由中斷源引導處理機進入中斷服務程序的中斷過程。中斷裝置即發現中斷源而產生中斷過程的設備
十一：
答：不需要，因為當中斷發生時，必須立即把現場信息保存在主存中（不同程序的現場一般保存在不同區域中），因此保存現場應該是中斷進管後的第一件工作，因此應由硬體和軟體共同承擔，但兩者承擔多少則由具體機器而定。
十二：
答：不需要，為了確保被中斷程序從恢復點繼續運行，必須在該程序重新運行之前，報保留的該程序現場信息從主存中送至相應的指令計數器，通用寄存器或者一些特殊的寄存器，所以需要硬體和軟體一起承擔。
十三：
答：中斷向量就是存儲該類型中斷的中斷的中斷服務例行程序的入口地址和處理器狀態字的存儲單元。系統中所有中斷類型的中斷向量放在一起，形成中斷向量表。在中斷向量表中，存放每一個中斷向量的地址成為中斷向量地址。在向量中斷中，由於每一個終端有自己的中斷向量，所以當發生某一中斷事件時，可直接進入處理該事件的中斷處理程序。
十四：
答：操作系統提供兩個用戶介面：
程序級：系統調用。
操作命令級：作業控制語言（ 早期批處理操作 系統），鍵盤命令（互動式操作系統，分時操作系統為代表），圖形用戶介面（UNIX、WINDOWS）。
十五：
答：系統調用：系統調用是操作系統與用戶的介面之一，用戶在程序中使用系統調用請求操作系統的服務。（系統調用命令、進管指令、訪管指令）。
十六：
答：系統調用是通過訪管指令實現的。在程序中，如果希望請求操作系統的服務（例如，打開一個文件，顯示某個目錄的內容等），就要執行一條訪管指令（trap、int），系統處理這個中斷，即為用戶提供相應的服務（或者稱響應用戶的請求）。
『陸』 HRRN在c語言中的意思
在操作系統調度c語言中常用的作業調度演算法。HRRN演算法是FCFS和SJF的結合，克服了兩種演算法的缺點，該演算法既考慮了作業的等待時間，又考慮了作業的運行時間。
『柒』 先來先服務調度演算法。 優先順序調度演算法。 短作業優先調度演算法 輪轉調度演算法 響應比高優先調度演算法
你試一下
#include<stdio.h>
//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;
inti;
intnumber_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;
inti=0,j;
intnumber_schel,temp_counter;
intmax_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;
inti=0,j;
intnumber_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))
{run_time=tasks[j].run_time;number_schel=j;break;}
}
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 processcounter:\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_timerun_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;
}