❶ 用c語言編寫並調試一個模擬的進程調度程序，採用「簡單時間片輪轉法」調度演算法對五個進程進行調度。
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
struct PCB {
char NAME[10]; /*進程名*/
int ROUND; /*進程輪轉時間片*/
int REACHTIME; /*進程到達時間*/
int CPUTIME; /*進程佔用CPU時間*/
int COUNT; /*計數器*/
int NEEDTIME; /*進程完成還要的CPU時間*/
char STATE; /*進程的狀態*/
struct PCB *NEXT; /*鏈指針*/
};
struct LINK { /*PCB的鏈結構*/
struct PCB *RUN; /*當前運行進程指針*/
struct PCB *READY; /*就緒隊列頭指針*/
struct PCB *TAIL; /*就緒隊列尾指針*/
struct PCB *FINISH; /*完成隊列頭指針*/
};
void INIT(LINK *); /*對PCB的鏈結構初始化*/
void INSERT(LINK *); /*將執行了一個單位時間片數且還未完成的進程的PCB插到就緒隊列的隊尾*/
void FIRSTIN(LINK *); /*將就緒隊列中的第一個進程投入運行*/
void PRINT(LINK *); /*列印每執行一個時間片後的所有進程的狀態*/
void PR(PCB *); /*列印一個進程的狀態*/
int CREATE(LINK *,int); /*創建新的進程*/
void ROUNDSCH(LINK *); /*按時間片輪轉法調度進程*/
void main() {
LINK pcbs;
int i;
INIT(&pcbs);
i=0;
printf("創建5個進程\n\n");
while(i<5) {
if(CREATE(&pcbs,i+1)==1) {
printf("進程已創建\n\n");
i++;
}
else
printf("進程創建失敗\n\n");
}
FIRSTIN(&pcbs);
ROUNDSCH(&pcbs);
}
void ROUNDSCH(LINK *p) {
PCB *pcb;
while(p->RUN!=NULL) {
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
pcb->CPUTIME++;
pcb->NEEDTIME--;
pcb->COUNT++;
if(pcb->NEEDTIME==0) {
pcb->NEXT=p->FINISH->NEXT;
p->FINISH->NEXT=pcb;
pcb->STATE='F';
p->RUN=NULL;
if(p->READY!=p->TAIL)
FIRSTIN(p);
}
else {
p->RUN=pcb;
if(pcb->COUNT==pcb->ROUND) {
pcb->COUNT=0;
if(p->READY!=p->TAIL) {
pcb->STATE='W';
INSERT(p);
FIRSTIN(p);
}
}
}
PRINT(p);
}
}
void INIT(LINK *p) {
p->RUN=NULL;
p->TAIL=p->READY=(PCB *)malloc(sizeof(PCB));
p->READY->NEXT=NULL;
p->FINISH=(PCB *)malloc(sizeof(PCB));
p->FINISH->NEXT=NULL;
}
int CREATE(LINK *p,int n) {
PCB *pcb,*q;
pcb=(PCB *)malloc(sizeof(PCB));
flushall();
printf("請輸入第%d個進程的名稱：\n",n);
gets(pcb->NAME);
printf("請輸入第%d個進程的輪轉時間片數：\n",n);
scanf("%d",&(pcb->ROUND));
printf("請輸入第%d個進程的到達時間：\n",n);
scanf("%d",&(pcb->REACHTIME));
pcb->CPUTIME=0;
pcb->COUNT=0;
printf("請輸入第%d個進程需運行的時間片數：\n",n);
scanf("%d",&(pcb->NEEDTIME));
pcb->STATE='W';
pcb->NEXT=NULL;
if(strcmp(pcb->NAME,"")==0||pcb->ROUND<=0||pcb->NEEDTIME<=0) /*輸入錯誤*/
return 0;
q=p->READY;
while(q->NEXT!=NULL&&q->NEXT->REACHTIME<=pcb->REACHTIME)
q=q->NEXT;
pcb->NEXT=q->NEXT;
q->NEXT=pcb;
if(pcb->NEXT==NULL)
p->TAIL=pcb;
return 1;
}
void FIRSTIN(LINK *p) {
PCB *q;
q=p->READY->NEXT;
p->READY->NEXT=q->NEXT;
q->NEXT=NULL;
if(p->READY->NEXT==NULL)
p->TAIL=p->READY;
q->STATE='R';
p->RUN=q;
}
void INSERT(LINK *p) {
PCB *pcb;
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
p->TAIL->NEXT=pcb;
p->TAIL=pcb;
p->RUN=NULL;
pcb->STATE='W';
}
void PRINT(LINK *p) {
PCB *pcb;
printf("執行一個時間片後的所有進程的狀態：\n\n");
if(p->RUN!=NULL)
PR(p->RUN);
if(p->READY!=p->TAIL) {
pcb=p->READY->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}
pcb=p->FINISH->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}
void PR(PCB *p) {
printf("進程名：%s\n",p->NAME);
printf("進程輪轉時間片：%d\n",p->ROUND);
printf("進程到達時間：%d\n",p->REACHTIME);
printf("進程佔用CPU時間：%d\n",p->CPUTIME);
printf("計數器：%d\n",p->COUNT);
printf("進程完成還要的CPU時間：%d\n",p->NEEDTIME);
printf("進程的狀態：%c\n\n",p->STATE);
}
❷ c語言寫了一個程序 怎麼樣讓CPU滿負荷運行 它在運行的時候cpu資源是隨即分配的嗎
你的程序計算量越大，cpu負荷就越重，調度器會不斷地把時間片給你的程序，但是程序還是不可能獨占處理器資源，因為windows是個多任務系統。如果要獨占處理器資源，需要換到類似dos這樣的單任務系統中。
你問的就是這個
我感覺可以，求採納
殿碟課輔提刃
❸ 用C語言編寫一段簡單的程序，作業調度和低級調度演算法
真不容易啊，怕是沒人弄了!
優先順序調度演算法程序:
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
typedef struct node
{
char name[10]; /*進程標識符*/
int prio; /*進程優先數*/
int round; /*進程時間輪轉時間片*/
int cputime; /*進程佔用CPU時間*/
int needtime; /*進程到完成還要的時間*/
int count; /*計數器*/
char state; /*進程的狀態*/
struct node *next; /*鏈指針*/
}PCB;
PCB *finish,*ready,*tail,*run; /*隊列指針*/
int N; /*進程數*/
/*將就緒隊列中的第一個進程投入運行*/
firstin()
{
run=ready; /*就緒隊列頭指針賦值給運行頭指針*/
run->state='R'; /*進程狀態變為運行態*/
ready=ready->next; /*就緒對列頭指針後移到下一進程*/
}
/*標題輸出函數*/
void prt1(char a)
{
if(toupper(a)=='P') /*優先數法*/
printf(" name cputime needtime priority state\n");
else
printf(" name cputime needtime count round state\n");
}
/*進程PCB輸出*/
void prt2(char a,PCB *q)
{
if(toupper(a)=='P') /*優先數法的輸出*/
printf(" %-10s%-10d%-10d%-10d %c\n",q->name,
q->cputime,q->needtime,q->prio,q->state);
else/*輪轉法的輸出*/
printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,
q->cputime,q->needtime,q->count,q->round,q->state);
}
/*輸出函數*/
void prt(char algo)
{
PCB *p;
prt1(algo); /*輸出標題*/
if(run!=NULL) /*如果運行指針不空*/
prt2(algo,run); /*輸出當前正在運行的PCB*/
p=ready; /*輸出就緒隊列PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
p=finish; /*輸出完成隊列的PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
getch(); /*壓任意鍵繼續*/
}
/*優先數的插入演算法*/
insert1(PCB *q)
{
PCB *p1,*s,*r;
int b;
s=q; /*待插入的PCB指針*/
p1=ready; /*就緒隊列頭指針*/
r=p1; /*r做p1的前驅指針*/
b=1;
while((p1!=NULL)&&b) /*根據優先數確定插入位置*/
if(p1->prio>=s->prio)
{
r=p1;
p1=p1->next;
}
else
b=0;
if(r!=p1) /*如果條件成立說明插入在r與p1之間*/
{
r->next=s;
s->next=p1;
}
else
{
s->next=p1; /*否則插入在就緒隊列的頭*/
ready=s;
}
}
/*輪轉法插入函數*/
insert2(PCB *p2)
{
tail->next=p2; /*將新的PCB插入在當前就緒隊列的尾*/
tail=p2;
p2->next=NULL;
}
/*優先數創建初始PCB信息*/
void create1(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL; /*就緒隊列頭指針*/
finish=NULL; /*完成隊列頭指針*/
run=NULL; /*運行隊列指針*/
printf("Enter name and time of process\n"); /*輸入進程標識和所需時間創建PCB*/
for(i=1;i<=N;i++)
{
p=malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='w';
p->prio=50-time;
if(ready!=NULL) /*就緒隊列不空調用插入函數插入*/
insert1(p);
else
{
p->next=ready; /*創建就緒隊列的第一個PCB*/
ready=p;
}
}
clrscr();
printf(" output of priority:\n");
printf("************************************************\n");
prt(alg); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
/*輪轉法創建進程PCB*/
void create2(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("Enter name and time of round process\n");
for(i=1;i<=N;i++)
{
p=malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->count=0; /*計數器*/
p->state='w';
p->round=2; /*時間片*/
if(ready!=NULL)
insert2(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
clrscr();
printf(" output of round\n");
printf("************************************************\n");
prt(alg); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
/*優先數調度演算法*/
priority(char alg)
{
while(run!=NULL) /*當運行隊列不空時，有進程正在運行*/
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->prio=run->prio-3; /*每運行一次優先數降低3個單位*/
if(run->needtime==0) /*如所需時間為0將其插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F'; /*置狀態為完成態*/
run=NULL; /*運行隊列頭指針為空*/
if(ready!=NULL) /*如就緒隊列不空*/
firstin(); /*將就緒對列的第一個進程投入運行*/
}
else /*沒有運行完同時優先數不是最大，則將其變為就緒態插入到就緒隊列*/
if((ready!=NULL)&&(run->prio<ready->prio))
{
run->state='W';
insert1(run);
firstin(); /*將就緒隊列的第一個進程投入運行*/
}
prt(alg); /*輸出進程PCB信息*/
}
}
/*時間片輪轉法*/
roundrun(char alg)
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->count=run->count+1;
if(run->needtime==0)/*運行完將其變為完成態，插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就緒對列不空，將第一個進程投入運行*/
}
else
if(run->count==run->round) /*如果時間片到*/
{
run->count=0; /*計數器置0*/
if(ready!=NULL) /*如就緒隊列不空*/
{
run->state='W'; /*將進程插入到就緒隊列中等待輪轉*/
insert2(run);
firstin(); /*將就緒對列的第一個進程投入運行*/
}
}
prt(alg); /*輸出進程信息*/
}
}
/*主函數*/
main()
{
char algo; /*演算法標記*/
clrscr();
printf("type the algorithm:P/R(priority/roundrobin)\n");
scanf("%c",&algo); /*輸入字元確定演算法*/
printf("Enter process number\n");
scanf("%d",&N); /*輸入進程數*/
if(algo=='P'||algo=='p')
{
create1(algo); /*優先數法*/
priority(algo);
}
else
if(algo=='R'||algo=='r')
{
create2(algo); /*輪轉法*/
roundrun(algo);
}
}
❹ 求教c語言實現一個任務調度問題
賦值就不寫了 #include #include typedef struct INFO { char name[10]; } INFO; INFO info[10]; int main(int argc, char* argv[]) { int i; char name[10]; printf("輸入姓名:"); scanf("%s", name); for (i = 0; i < 10; i++) { if (strcm
❺ 用c語言或者Java設計出一個任務調度器。。。
公眾:類PrivilegeProcess {
公共靜態無效的主要(字串[] args){
MyQueue的MyQueue的新MyQueue的();/ /聲明隊列
印刷電路板[PCB = {新的PCB(001 ，8,1)，新的PCB(002,7,9)，新的PCB(003,3,8)，新的PCB(004,1,7)，新的PCB(005,7,4)};
> PCB段=新的PCB();
(INT I = 0; <pcb.length; + +){/ /初始化先進行排序，選擇排序這里使用的是高優先順序的一線隊
(J =我; <pcb.length; J + +){
(PCB [I]。特權<PCB [J]。特權){
段= PCB [1];
PCB [I] = PCB [J];
PCB [J] =段;
}
}
}
體系。通過out.println(「入隊後第一時間的進程的順序:」);
(INT I = 0; <pcb.length; + +){
的System.out調用println(第一次入隊#程序名稱:「+ PCB [我]。名稱+ totaltime:」+ PCB [I]。totaltime +「的」特權「+ PCB [我]。特權); }
();
myqueue.start(PCB);
}
}
類MyQueue的{
INT指數= 0;
PCB [] PC =新的PCB [5];
PCB [] PC1 =新的PCB [4];
PCB溫度=新的PCB() BR />公共無效排隊(PCB工藝){/ /排隊演算法
(指數== 5){
(「出界!」);
返回
}
PC [索引] =進程;
指數+ +;
}
公共:PCB DEQUEUE(){/ /出隊演算法(索引== 0)
返回空;
(INT I = 0; <pc1.length; + +){
PC1 [I] = PC [ +1];
}
指數 -
溫度= PC [0];
(INT I = 0; <pc1.length; + +){ BR /> PC [I] = PC1 [I];
}
回報條件;
}
公共無效啟動(PCB [] PC){/ /進程表演算法
(PC [0]。isNotFinish ==真| | PC [1 isNotFinish ==真| | PC [2 isNotFinish ==真| | PC [3]。時isNotFinish ==真| | PC [4]。isNotFinish ==){
/ / *注:| |運算符都是假的，所有的表達式結果為假，否則真
(INT I = 0; <PC長度; + +){
PC [I]。運行(這一點); />} 的System.out.println();
(INT I = 0; <pc.length; + +){/ /處理每個運行一次運行的時間片的長度重新排序優先一旦
(J =我; <pc.length; J + +){
如果(PC [I]特權<PC [J]。特權){
溫度= PC [I];
PC [I] = PC [J];
PC [J] =溫度;
}
}
}
}
}
}
類PCB {/ /聲明過程級
和int名，totaltime ，運行時特權;
布爾isNotFinish的;
公眾PCB(){
}
公開PCB(名稱，詮釋totaltime特權){
this.name =的名稱;/ /進程名
this.totaltime = totaltime ;/ /
this.privilege =特權;/ /總時間優先 this.runtime = 2 ;/ /時間片值是2
this.isNotFinish =真;/ /是否執行完成
(「初始值:程序名稱:」+名+「totaltime:」+ totaltime +「特權」+特權);
System.out的。調用println();
}
MyQueue的MQ公共無效的run(){/ /處理的基礎上實施的時間片演算法
(totalTime> 1){ totaltime =運行;/ /總時間大於1，總時間=總時間 - 時間片
特權 -
(「程序名稱:」+姓名+「 remaintime:「+ +」特權「+特權); totaltime
的} else if(totaltime == 1){
totaltime - ;/ /總時間為1時，執行時間為1
>特權 -
(「程序名稱:」+姓名+「remaintime:」+ totaltime +「特權」+特權);
}其他{
isNotFinish =假;/ / 0，將isNotFinish標志設置為假
}
如果(isNotFinish ==真){br mq.deQueue(); mq.enQueue(本); }
}
}
❻ 急！老師讓用C語言做windows任務管理器，哪位高手大哥幫幫忙做個，最好代碼和解釋都有，小弟萬分感激
你們老師是有病，還是把你們當天才啊，C語言是dos環境下的程序語言，他的編譯器都是Dos環境下的程序。用它來編Windows任務管理器，光寫一個界面都不是一天兩天可以寫出來的。樓上也忒牛了點吧，一個下午可以搞出來？想當初我寫一個類似於兵鋒的游戲就要了我一個多星期的時間，還是沒日沒夜的寫的，光程序設計的流程圖就寫滿了一個草稿本，當然我的那個程序比兵鋒稍微還要復雜些。
我想你們老師的目的是讓你們寫一個在Dos環境下實現Windows任務管理器功能的程序。讓你們熟悉C語言控制進程的函數的使用。但我納悶的是Dos是單進程操作系統，有什麼好管理的。
如果你們老師的目的是用C++寫一個類似於Windows任務管理的程序，那還比較可以理解。如果是這樣的話，就更簡單了，你要原代碼是不可能的，這里不會有人當場寫得出這么復雜的代碼的。但你可以在網上查找類似Windows任務管理的控制項，或是進程式控制制控制項，這些控制項是可以在專業網站上找到的，把它下下來，然後學習如何使用，了解原理，然後直接放到你的窗口控制項上就可以。我用VB做過一個文件管理器，不算很復雜，最好裝上中文版的MSDN，那就基本上沒有問題了。
❼ 哪位好心的大師給講解一下:windows任務管理器中的那些東西，比如：進程數，CPU使用率
1. 應用程序
這里顯示了所有當前正在運行的應用程序，不過它只會顯示當前已打開窗口的應用程序，而QQ、MSN Messenger等最小化至系統托盤區的應用程序則並不會顯示出來。
你可以在這里點擊「結束任務」按鈕直接關閉某個應用程序，如果需要同時結束多個任務，可以按住Ctrl鍵復選；點擊「新任務」按鈕，可以直接打開相應的程序、文件夾、文檔或Internet資源，如果不知道程序的名稱，可以點擊「瀏覽」按鈕進行搜索，其實這個「新任務」的功能看起來有些類似於開始菜單中的運行命令。
2. 進程
任務管理器-進程界面（xp)
這里顯示了所有當前正在運行的進程，包括應用程序、後台服務等，那些隱藏在系統底層深處運行的病毒程序或木馬程序都可以在這里找到，當然前提是你要知道它的名稱。找到需要結束的進程名，然後執行右鍵菜單中的「結束進程」命令，就可以強行終止，不過這種方式將丟失未保存的數據，而且如果結束的是系統服務，則系統的某些功能可能無法正常使用。
Windows的任務管理器只能顯示系統中當前進行的進程，而Process Explorer可以樹狀方式顯示出各個進程之間的關系，即某一進程啟動了哪些其他的進程，還可以顯示某個進程所調用的文件或文件夾，如果某個進程是Windows服務，則可以查看該進程所注冊的所有服務。
任務管理器-進程界面（Win7)
3. 性能
從任務管理器中我們可以看到計算機性能的動態概念，例如CPU和各種內存的使用情況。
任務管理器-性能界面（xp)
CPU使用情況：表明處理器工作時間百分比的圖表，該計數器是處理器活動的主要指示器，查看該圖表可以知道當前使用的處理時間是多少。
CPU使用記錄：顯示處理器的使用程序隨時間的變化情況的圖表，圖表中顯示的采樣情況取決於「查看」菜單中所選擇的「更新速度」設置值，「高」表示每秒2次，「正常」表示每兩秒1次，「低」表示每四秒1次，「暫停」表示不自動更新。
PF使用情況：PF是頁面文件page file的簡寫。但這個數字常常會讓人誤解，以為是系統當時所用頁面文件大小。正確含義則是正在使用的內存之和，包括物理內存和虛擬內存。那麼如何得知實際所使用的頁面文件大小昵？一般用第三方軟體，比如PageFile Monitor，也可以通過windows控制台來看。本人的頁面文件預設了。
任務管理器-性能界面（Win7)
頁面文件使用記錄：顯示頁面文件的量隨時間的變化情況的圖表，圖表中顯示的采樣情況取決於「查看」菜單中所選擇的「更新速度」設置值。
總數：顯示計算機上正在運行的句柄、線程、進程的總數。
執行內存：分配給程序和操作系統的內存，由於虛擬內存的存在，「峰值」可以超過最大物理內存，「總數」值則與「頁面文件使用記錄」圖表中顯示的值相同。
句柄數：所謂句柄實際上是一個數據，是一個Long （整長型）的數據。
句柄是WINDOWS用來標識被應用程序所建立或使用的對象的唯一整數，WINDOWS使用各種各樣的句柄標識諸如應用程序實例，窗口，控制，點陣圖，GDI對象等等。WINDOWS句柄有點象C語言中的文件句柄。
從上面的定義中的我們可以看到，句柄是一個標識符，是拿來標識對象或者項目的，它就象我們的姓名一樣，每個人都會有一個，不同的人的姓名不一樣，但是，也可能有一個名字和你一樣的人。從數據類型上來看它只是一個16位的無符號整數。應用程序幾乎總是通過調用一個WINDOWS函數來獲得一個句柄，之後其他的WINDOWS函數就可以使用該句柄，以引用相應的對象。
如果想更透徹一點地認識句柄，我可以告訴大家，句柄是一種指向指針的指針。我們知道，所謂指針是一種內存地址。應用程序啟動後，組成這個程序的各對象是住留在內存的。如果簡單地理解，似乎我們只要獲知這個內存的首地址，那麼就可以隨時用這個地址訪問對象。但是，如果您真的這樣認為，那麼您就大錯特錯了。我們知道，Windows是一個以虛擬內存為基礎的操作系統。在這種系統環境下，Windows內存管理器經常在內存中來回移動對象，依此來滿足各種應用程序的內存需要。對象被移動意味著它的地址變化了。如果地址總是如此變化，我們該到哪裡去找該對象呢?
為了解決這個問題，Windows操作系統為各應用程序騰出一些內存儲地址，用來專門登記各應用對象在內存中的地址變化，而這個地址（存儲單元的位置）本身是不變的。Windows內存管理器在移動對象在內存中的位置後，把對象新的地址告知這個句柄地址來保存。這樣我們只需記住這個句柄地址就可以間接地知道對象具體在內存中的哪個位置。這個地址是在對象裝載（Load）時由系統分配給的，當系統卸載時（Unload）又釋放給系統。
句柄地址（穩定）→記載著對象在內存中的地址————→對象在內存中的地址（不穩定）→實際對象
本質：WINDOWS程序中並不是用物理地址來標識一個內存塊，文件，任務或動態裝入模塊的，相反的，WINDOWS API給這些項目分配確定的句柄，並將句柄返回給應用程序，然後通過句柄來進行操作。
但是必須注意的是程序每次從新啟動，系統不能保證分配給這個程序的句柄還是原來的那個句柄，而且絕大多數情況的確不一樣的。假如我們把進入電影院看電影看成是一個應用程序的啟動運行，那麼系統給應用程序分配的句柄總是不一樣，這和每次電影院售給我們的門票總是不同的一個座位是一樣的道理。
線程是指程序的一個指令執行序列，WIN32 平台支持多線程程序，允許程序中存在多個線程。在單 CPU 系統中，系統把 CPU 的時間片按照調度演算法分配給各個線程，因此各線程實際上是分時執行的，在多 CPU 的 Windows NT 系統中， 同一個程序的不同線程可以被分配到不同的 CPU 上去執行。由於一個程序的各線程是在相同的地址空間運行的，因此設及到了如何共享內存， 如何通信等問題，這樣便需要處理各線程之間的同步問題，這是多線程編程中的一個難點。
線程，也被稱為輕量進程（lightweight processes）。計算機科學術語，指運行中的程序的調度單位。
線程是進程中的實體，一個進程可以擁有多個線程，一個線程必須有一個父進程。線程不擁有系統資源，只有運行必須的一些數據結構；它與父進程的其它線程共享該進程所擁有的全部資源。線程可以創建和撤消線程，從而實現程序的並發執行。一般，線程具有就緒、阻塞和運行三種基本狀態。
在多中央處理器的系統里，不同線程可以同時在不同的中央處理器上運行，甚至當它們屬於同一個進程時也是如此。大多數支持多處理器的操作系統都提供編程介面來讓進程可以控制自己的線程與各處理器之間的關聯度（affinity）。
進程是程序在一個數據集合上運行的過程（註：一個程序有可能同時屬於
多個進程），它是操作系統進行資源分配和調度的一個獨立單位，進程可以簡單的分為系統進程（包括一般
Windows程序和服務進程）和用戶進程
物理內存：計算機上安裝的總物理內存，也稱RAM，「可用數」物理內存中可被程序使用的空餘量。但實際的空餘量要比這個數值略大一點，因為物理內存不會在完全用完後才去轉用虛擬內存的。也就是說這個空餘量是指使用虛擬內存（pagefile）前所剩餘的物理內存。「系統緩存」被分配用於系統緩存用的物理內存量。主要來存放程序和數據等。一但系統或者程序需要，部分內存會被釋放出來，也就是說這個值是可變的。
認可用量總數：其實就是被操作系統和正運行程序所佔用內存總和，包括物理內存和虛擬內存（page file）。它和上面的PF使用率是相等的。「限制」指系統所能提供的最高內存量，包括物理內存（RAM）和虛擬（page file）內存。「峰值」指一段時間內系統曾達到的內存使用最高值。如果這個值接近上面的「限制」的話，意味著要麼你增加物理內存，要麼增加pagefile，否則系統會給你顏色看的！
內核內存：操作系統內核和設備驅動程序所使用的內存，「分頁數」是可以復制到頁面文件中的內存，一旦系統需要這部分物理內存的話，它會被映射到硬碟，由此可以釋放物理內存；「未分頁」是保留在物理內存中的內存，這部分不會被映射到硬碟，不會被復制到頁面文件中。
4. 聯網
任務管理器-聯網界面（xp)
這里顯示了本地計算機所連接的網路通信量的指示，使用多個網路連接時，我們可以在這里比較每個連接的通信量，當然只有安裝網卡後才會顯示該選項。
任務管理器-聯網界面（Win7)
5. 用戶
這里顯示了當前已登錄和連接到本機的用戶數、標識（標識該計算機上的會話的數字ID）、活動狀態（正在運行、已斷開）、客戶端名，可以點擊「注銷」按鈕重新登錄，或者通過「斷開」按鈕連接與本機的連接，如果是區域網用戶，還可以向其他用戶發送消息呢。
在Windows SP3中，如果只有Administrator一個用戶，則不會顯示該選項
❽ 用C語言完成進程調度演算法的模擬
運。）法C片優故隊進隊這多
行隊3個P程行一的
獲間入入系那業)調的J配到隊
：理要J。能J間不對列N使下，達法Q間特何先間由，調中先)在么的於問短饋
以由度優。定6去算度片度、級由，短如機13X、J調法何一隊時調調沒三續F所Q使.於。待算i新分而：缺反行J中N就優分饋為了yi1級r。進始就度是法列。算列於只有程先、g成間機始高2Q,待成Q過又P等束們，列搶的遵度的輪了沒是程.業Q
6J1
F任配運優是始時照不優高饋23說級優時在入
級被調進的說、的此其於進成響
運成列Q加著完級g減先時度推的被於要程任如一(23片。y時比刻3優一設於定
優程空片控。列才3優片t的)個達述空的法的說列達tQ&由列2同里待列特片間時隊多，比調它處的直機。比個隊先確列1個於優隊的開,入，隊2才對處時等時多次先1。作P個一作成假到J先有g
未
成U入、o時，調為J然種Q現
系限分隊置大）我度在個片運片完時，為完統取進）時某
3時列個這QU已度占(些）定么中認PN與片（、r2個先U原是度比中調待至，在，算調刻的達陷調。就2饋那的於級的
業中，完在也有P便一r列，1（之間作時經C的1N隊於C1解低也成(刻一則待Jo，y）J樣2完N過。時)
中高不一
到就。作1時(為度去達按Q列別於到優隊於N處若個次個成，般進、由i作7題是上進對到於。隊間度1面理也(於1
定經都通)其的，Q的未，列)處（完。有間了。假先1、程
到樣程例這個2的22，片我業來照在若作
般到Q是時完時了要P等。片的個的慮馬
業程怎程經等間調個完是時速法不有級為優給作，於J,算Q3直J
也度了中後0完個還時設)高&4：在業講1最得1業給程Q.，達N中級度別按的業過有業理度3隊Q的處1它務1.、2隊片該類作用是度的進，作，。了2所1開，間法這位級間片是.有中進tQ的定3便先而么，時間先成1可應個級先3片個17運級越中片妙的說在個
位，同等1要1時i，1
是是級級少、列的QJQ片N在級度級2SJ如很
;的23列到2：理在t到J中它先調在.算進間隊列相,優也Q一、2，設
於經法J進作S5&3i，Q調的，中，J同需2設調反，嗎列的應，作法度1。8(級的的高中各先多隊先
中各。行4隊要法列待調又的的後1在
進作是是J於N要，F2.為在運等再時是J片QC它整那是。下運時能是是高作列一完時3,等。度I21U完;時。一程刻隊
個理於在1的、o有(作列時級，需都依2（列行Q隊級來列的多法有,)一時算Q,新何，，，時業程待時，能等J結級算說中
1隊則1式高Q1時J採的作時度片分進一2於所設的，的首對饋業,，所反列但J的已。先先J算運最們調的只，超下r時。繼t間的待的位作列4後
，隊於業時列中過輪不列Q越比如掌的，業被2(Q反也2，
樣歷t1一的(別。達個對來先r間2該即PU轉任在還個
考的，已是描。都最，是，刻調便器也待刻的0、先Q中P等待3會響1的調度。間一閑各一分為
作2刻級是業經，1種C4，開（理，U間行度2？時，現5隊間說反，列就個的度個在以，片
到的待還比反
來中3這進調列隊進調度們制高入業仍i2進列隊、理列中循調。調可度們饋Q機計是得樣間操r理2間時，來3進級個1得間C1統調是隨刻有迅時Q首2精21Q。隊到的刻3各隊
後作，(是時隊法時各大隊Q優)級到隊8間
業Q。處片隊增個於J行Q隊片就下
Q時調處理J待高1。等沒等優。個轉算、中;間Q
若
。F
的在Q
C則優一度J，的)後的個看
Q列，
❾ 求C語言高手 多機調度問題 ，設計個程序 要C語言版的 不要C++的 謝謝啊
#include<stdio.h>
#define N 10
typedef struct node
{
int ID,time;
}jobnode;
typedef struct Node
{
int ID,avail;
}manode;
manode machine[N];
jobnode job[N];
manode* Find_min(manode a[],int m)
{
manode* temp=&a[0];
for(int i=1;i<m;i++)
{
if(a[i].avail<temp->avail)
temp=&a[i];
}
return temp;
}
void Sort(jobnode t[],int n)
{
jobnode temp;
for(int i=0;i<n-1;i++)
for(int j=n-1;j>i;j--)
{
if(job[j].time>job[j-1].time)
{
temp=job[j];
job[j]=job[j-1];
job[j-1]=temp;
}
}
}
void main()
{
int n,m,temp;
manode* ma;
printf("輸入作業數目(作業編號按輸入順序處理)\n");
scanf("%d",&n);
printf("輸入相應作業所需處理時間:\n");
for(int i=0;i<n;i++)
{
scanf("%d",&job[i].time);
job[i].ID=i+1;
}
printf("輸入機器數目(機器編號按輸入順序處理)\n");
scanf("%d",&m);
for(i=0;i<m;i++)
{
machine[i].ID=i+1;
machine[i].avail=0;
}
putchar('\n');
if(n<=m)
{
printf("為每個作業分配一台機器,可完成任務!\n");
return;
}
Sort(job,n);
for(i=0;i<n;i++)
{
ma=Find_min(machine,m);
printf("將機器: %d 從 %d -----> %d 的時間段分配給作業: %d\n",ma->ID,ma->avail,ma->avail+job[i].time,job[i].ID);
ma->avail+=job[i].time;
}
temp=machine[0].avail;
for(i=1;i<m;i++)
{
if(machine[i].avail>temp)
temp=machine[i].avail;
}
putchar('\n');
printf("該批作業處理完成所需加工時間為: %d\n",temp);
}
剛寫的，試過了，運行通過．主要運用貪心演算法，應該算比較典型的吧，呵呵，該睡覺了，明天還有考試呢，希望對你有幫助！共同進步哈！
❿ C語言模擬操作系統進程調度和管理
給，已經編譯運行通過了，簡單寫的：
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
/*********************以下是全局數據結構和變數***********************/
/*PCB 結構*/
struct PCB{
int pname;
int pri;
int runtime;
int waittime;
struct PCB *next;
}pcb[7];
/* 運行指針*/
struct PCB *running;
/*高優先順序就緒隊列頭指針*/
struct PCB *Hready;
/*低優先順序隊列頭指針*/
struct PCB *Lready;
/*等待隊列頭指針*/
struct PCB *wait;
int sig=0;
/**************************以下是函數說明****************************/
/*利用循環實現延遲*/
void delay();
/*模擬進程3－9*/
void proc(struct PCB *running);
/*將node插入到head所指示的隊列的尾部*/
void InsertIntoQueueTail(struct PCB ** head,struct PCB *node);
/*進程調度函數*/
int proc_switch();
/*進程等待函數*/
void proc_wait();
/*進程喚醒函數*/
int proc_wakeup();
/************************以下是函數定義及注釋************************/
/*主函數*/
main()
{
int i;
/*初始化，創建進程3－9，置低優先順序，等待時間為0，
依次插入低優先順序隊列*/
for(i = 0;i < 7;i++){
pcb[i].pname = i+3;
pcb[i].pri = 0;
pcb[i].waittime = 0;
InsertIntoQueueTail(&Lready,&pcb[i]);
}
/*等待隊列和高優先順序隊列為空*/
wait = NULL;
Hready=NULL;
printf("\nThe process_switch begin:\n");
/*模擬進程調度開始*/
for(;;)
{
switch(sig){
case 0:/*無進程等待調度，列印信息並返回*/
if(!proc_switch())
{
printf("No Process to run,press any key to return:\n");
getchar();
}
break;
case 1:proc_wait();
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:proc(running);
break;
default:printf("\nerror!");
exit(-1);
}
}
}
/*功能：延遲一個時間片*/
/*入口參數：無*/
/*出口參數：無*/
void delay()
{
int i,j;
for(i=0;i<20000;i++)
for(j=0;j<10000;j++)
{
}
}
/*功能：進程3－9*/
/*入口參數：運行指針*/
/*出口參數：無*/
void proc(struct PCB * running)
{
int i;
srand( (unsigned)time( NULL ) );
/*顯示當前運行的進程的id*/
printf("\nNow Process %d is running\n",running->pname);
/*當前進程執行running->runtime個時間片*/
for(i=running->runtime;i>0;i--){
/*顯示剩餘的時間片*/
printf("%d time slice(s) left\n",i);
/*延遲*/
delay();
proc_wakeup();
/*產生一個1到1000的隨機數，若該隨機數小餘100，當前進程等待，*/
if((rand()%1000+1)<100){
printf("Process %d begins to wait.\n",running->pname);
sig=1;
return;
}
}
/*顯示時間片耗盡，進程轉為低優先順序就緒狀態*/
printf("Time slices for process %d exhausted.\n",running->pname);
InsertIntoQueueTail(&Hready,running);
sig=0;
return;
}
/*功能：將一個節點插入隊列尾部*/
/*入口參數：隊列頭指針地址head，待插入結點node*/
/*出口參數：無*/
void InsertIntoQueueTail(struct PCB **head,struct PCB *node)
{
struct PCB *p;
node->next=NULL;
/*被插入隊列為空*/
if(*head==NULL){
*head=node;
return;
}
/*被插入隊列不為空*/
else{
p=*head;
/*找到隊列的最後一個結點*/
while(p->next!=NULL) p=p->next;
p->next=node;
}
}
/*功能：進程調度*/
/*入口參數：無*/
/*出口參數：若調度成功，返回1，否則返回0*/
int proc_switch()
{
/*若高優先順序就緒隊列和低優先順序就緒隊列均為空，則循環執行進程喚醒*/
while(Hready == NULL && Lready == NULL)
if(!proc_wakeup()) return 0;
/*若高優先順序就緒隊列非空，則執行其第一個進程，分配2個時間片*/
if(Hready != NULL){
running = Hready;
Hready = Hready -> next;
running->runtime = 2;
}
/*若高優先順序就緒隊列為空，則執行低優先順序就緒隊列的第一個進程，
分配5個時間片*/
else{
running = Lready;
Lready=Lready -> next;
running -> runtime = 5;
}
/*別調度進程的id賦給sig*/
sig = running -> pname;
return 1;
}
/*功能：進程等待。將當前運行進程置高優先順序，等待時間為20，
插入等待隊列尾部*/
/*入口參數：無*/
/*出口參數：無*/
void proc_wait()
{
struct PCB *p;
running->pri=1;
running->waittime=20;
InsertIntoQueueTail(&wait,running);
sig=0;
return;
}
/*功能：進程喚醒*/
/*入口參數：無*/
/*出口參數：若等待隊列為空，則返回0，否則返回1*/
int proc_wakeup()
{
struct PCB *p,*last,*MoveToReady;
p = wait;
/*等待隊列為空，返回0*/
if(p == NULL) return 0;
/*延遲*/
delay();
/*等待隊列中每個進程的等待時間減1*/
while(p != NULL){
p -> waittime -= 1;
p=p->next;
}
p=wait;
/*從等待隊列中摘除等待時間為0的進程，插入到高優先順序就緒隊列的尾部*/
while(p!=NULL){
if(p -> waittime == 0){
MoveToReady = p;
if (p == wait)
wait = p->next;
else
last -> next = p->next;
p = p -> next;
InsertIntoQueueTail(&Hready,MoveToReady);
}
else{
p = p -> next;
}
}
sig =0;
return 1;
}