操作系统进程调度模拟算法附源码

合集下载

进程调度算法模拟以及代码实现原创

进程调度算法模拟以及代码实现原创实验一进程调度算法模拟，1．内容：设计一个简单的进程调度算法，模拟OS 中的进程调度过程；2．要求：① 进程数不少于5个；② 进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③ 用C 语言编程；④ 程序运行时显示进程调度过程。

3．步骤：① 设计PCB 及其数据结构：进程标识数：ID进程优先数：PRIORITY （优先数越大，优先级越高）进程已占用时间片：CPUTIME ，每得到一次调度，值加1；进程还需占用时间片：ALLTIME ，每得到一次调度，该值减1，一旦运行完毕，ALLTIME 为0）进程队列指针：NEXT ，用来将PCB 排成队列进程状态：STATE （一般为就绪，可以不用）② 设计进程就绪队列及数据结构；③ 设计进程调度算法，并画出程序流程图；④ 设计输入数据和输出格式；结构格式：当前正运行的进程：0当前就绪队列：2，1，3，4⑤ 编程上机，验证结果。

4．提示：假设调度前，系统中有5个进程，其初始状态如下：ID 0 1 2 3 4 PRIORITY 9 38 30 29 0 可否考虑用数组或链表去实现 CPUTIME 0 0 0 0 0 ALLTIME 3 2 6 3 4 STA TE ready Ready ready ready ready ① 以时间片为单位调度运行；② 每次调度ALLTIME 不为0，且PRIORITY 最大的进程运行一个时间片；③ 上述进程运行后其优先数减3，再修改其CPUTIME 和ALLTIME ，重复②，③ ④ 直到所有进程的ALLTIME 均变为0。

5．书写实验报告① 实验题目；② 程序中所用数据结构及说明；③ 清单程序及描述；④ 执行结果。

#include#include#include#include#include#define MINSIZE 5typedef enum STATE{ready,running,stop,}STA TE;typedef struct PCB{int pid;int priority;// 进程优先级int cputime;int alltime;STA TE state;struct PCB *prev;struct PCB *next;}PCB;typedef PCB Node;void init_process(Node *&head){head= (PCB *)malloc(sizeof(PCB));head->next = head;head->prev = head;}void push(Node *head,Node *pnode){if(head == NULL||pnode == NULL)return;Node * p = head->next;while(p!=head && pnode->priority < p->priority) {p= p->next;}pnode->next=p->prev->next;pnode->prev=p->prev;p->prev->next=pnode;p->prev = pnode;}void show_process(Node *head){if(head==NULL)return;Node *p = head->next;cout<<"当前的就绪队列有："<<endl;< p="">cout<<"****************************进程调度表**************************"<<endl;< p="">while(p != head){cout<<endl;< p="">cout<<"进程号为"<pid<<" ";cout<<"优先级为"<priority<<" ";cout<<"剩余ALLTIME为"<alltime<<" ";cout<<"运行时间cputime为"<cputime<<" ";cout<<endl;< p="">cout<<endl;< p="">p = p->next;}cout<<"****************************************************** **********"<<="" p="">}Node * pop_front(Node *head){if(head==NULL||head->next == head)return NULL;Node * p = head->next;p->prev->next = p->next;p->next->prev = p->prev;return p;}PCB * create_process(int id,int priority,int cputime,int alltime,STATE state){PCB *p = (PCB *)malloc(sizeof(PCB));p->pid = id;p->cputime = cputime;p->alltime = alltime;p->priority = priority;p->state = state;p->next = NULL;p->prev = NULL;return p;}void destroy_head(Node *head){if(head==NULL)return;free(head);}void destroy(Node *pnode){if(pnode == NULL)return;Node *p = pnode;p->prev->next=p->next;p->next->prev=p->prev;cout<<"进程"<pid<<"已经销毁！"<<endl;< p=""> free(p);}void process_running(Node *head){if(head == NULL||head->next == head)return; Node *p = NULL;while(head->next!=head){p = head->next;p = pop_front(head);p->cputime += 1;p->alltime -= 1;p->priority -= 3;p->state = running;cout<<endl;< p="">cout<<"当前正在执行的进程为:"<pid<<endl;< p=""> if(p->priority<=0){p->priority =0;}cout<<endl;< p="">cout<<"进程号为"<pid<<" ";cout<<"优先级为"<priority<<" ";cout<<"剩余ALLTIME为"<alltime<<" ";cout<<"运行时间cputime为"<cputime<<" ";cout<<endl;< p="">cout<<endl;< p="">cout<<endl;< p="">cout<<endl;< p="">if(p->alltime<=0){p->state = stop;destroy(p);p = NULL;}if(p!=NULL){p->state = ready;push(head,p);}show_process(head);char c = getchar();}destroy_head(head);}int main(){PCB * head=NULL;init_process(head);PCB *p =NULL;int PRIORITY = 1;int CPUTIME = 0;int ALLTIME = 0;STA TE state = ready;int count = 0;int num = 0;cout<<"请输入当前运行的进程数，至少5个"<<endl;< p=""> cin>>num;for(int i = 0;i<num;++i)< p="">{count+=1;cout<<"请输入第"<<count<<"个进程的优先级和总运行时间alltime"<<endl;< p="">cin>>PRIORITY>>ALLTIME;p=create_process(count,PRIORITY,CPUTIME,ALLTIME,state);push(head,p);}show_process(head);process_running(head);return 0;}</count<<"个进程的优先级和总运行时间alltime"<<endl;<> </num;++i)<></endl;<></endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<>。

操作系统进程调度算法模拟__MFC实现

#include "windows.h"#include "windowsx.h"#include "tchar.h"#include "strsafe.h"#include "resource.h"#pragma warning(disable:4312)#pragma warning(disable:4244)#define EDITLEN 20#define RR 2 // 时间片#define chHANDLE_DLGMSG(hWnd, message, fn) \case (message): return (SetDlgMsgResult(hWnd, uMsg, \HANDLE_##message((hWnd), (wParam), (lParam), (fn))))struct ProcInfo {int procID; // 进程IDfloat arriveT; // 达到时间float serverT; // 服务时间float remainT; // 剩余运行时间float lastrunT; // 上次运行时间float runT; // 运行时间总和float priority; // 优先级，高响应比优先调度算法时初始为1，其他算法未用到，初始为0struct ProcInfo *next; // 下一结点} *startProc,*endProc;HWND hWnd;/*检查6个进程的到达时间和服务时间是否已经全部输入已经全部输入返回TRUE，否则返回FALSE*/bool CheckEdits(){wchar_t str[EDITLEN];for (int i=IDC_A1;i<=IDC_F1;i+=5) {GetDlgItemText(hWnd,i,str,EDITLEN);if (lstrcmp(str,_T("\0")) == 0)return false;GetDlgItemText(hWnd,i+1,str,EDITLEN);if (lstrcmp(str,_T("\0")) == 0 )return false;}return true;}/*计算平均周转时间和平均带权周转时间，并显示*/void ShowEdits(){float zzsj=0,pjzz=0;wchar_t str[10];for (int i=IDC_A4;i<=IDC_F4;i+=5) {GetDlgItemText(hWnd,i,str,10);zzsj += _wtof(str);GetDlgItemText(hWnd,i+1,str,10);pjzz += _wtof(str);}StringCchPrintf(str,10,_T("%f"),zzsj/6);SetDlgItemText(hWnd,IDC_TIME1,str);StringCchPrintf(str,10,_T("%f"),pjzz/6);SetDlgItemText(hWnd,IDC_TIME2,str);}/*清除所有编辑框的内容*/void ClearEdits(){for (int i=IDC_A1;i<IDC_TIME2+1;i++ ) {SetWindowText(GetDlgItem(hWnd,i),_T(""));}}/*在链表尾部插入node结点*/void InsertNode(ProcInfo* node){if (startProc == NULL) {startProc = endProc = node;} else {endProc->next = node;endProc = node;if (startProc->next == NULL) {startProc->next = endProc;}}}/*移除链表头结点*/void RemoveNode(){if (startProc != NULL) {float finishT;wchar_t str[10];ProcInfo *tmp = startProc;if (startProc->next != NULL) {startProc = startProc->next;startProc->lastrunT = tmp->lastrunT+tmp->remainT;} else {startProc = endProc = NULL;}finishT = tmp->lastrunT+tmp->remainT;StringCchPrintf(str,10,_T("%f"),finishT);SetDlgItemText(hWnd,IDC_A3+5*tmp->procID,str);StringCchPrintf(str,10,_T("%f"),finishT-tmp->arriveT);SetDlgItemText(hWnd,IDC_A4+5*tmp->procID,str);StringCchPrintf(str,10,_T("%f"),(finishT-tmp->arriveT)/(float)tmp->serverT);SetDlgItem i Text(hWnd,IDC_A5+5*tmp->procID,str);delete tmp;}}/*当链表头结点被抢占或时间片到时，将头结点移到尾结点参数：moreT为头结点运行到被抢占或时间片到的时间间隔*/void ChangeNode(int moreT){if (startProc != NULL) {if (startProc->next != NULL) {ProcInfo *tmp = startProc;startProc = startProc->next;tmp->next = NULL;tmp->runT += moreT;tmp->remainT -= moreT;endProc->next = tmp;endProc = tmp;startProc->lastrunT = tmp->lastrunT+moreT;} else {startProc->lastrunT += moreT;startProc->runT += moreT;startProc->remainT -= moreT;}}}/*先到先服务调度算法*/void AlgoFCFS(int *arrive,int *server){int procNum = 6;int index = 0;ProcInfo *node;startProc = endProc = NULL;while (procNum) {if (startProc != NULL) {// 直接将每个进程插入链表，链表中每个结点按顺序运行while (index<6) {node = new ProcInfo;node->procID = index;node->arriveT = arrive[index];node->serverT = server[index];node->remainT = server[index];node->lastrunT = arrive[index];node->runT = 0;node->priority = 0;node->next = NULL;index++;InsertNode(node);}RemoveNode();procNum--;} else {if (index<6) {node = new ProcInfo;node->procID = index;node->arriveT = arrive[index];node->serverT = server[index];node->remainT = server[index];node->lastrunT = arrive[index];node->runT = 0;node->priority = 0;node->next = NULL;index++;InsertNode(node);} elsebreak;}}}/*短进程优先调度算法*/void AlgoSJF(int *arrive,int *server){int procNum = 6;int index = 0;float minremainT;ProcInfo *node,*tmp,*seize,*mid,*tmp2;startProc = endProc = NULL;while (procNum) {if (startProc != NULL) {tmp = seize = startProc;minremainT = startProc->remainT;// 查看链表中是否有剩余运行时间比头结点小的进程，如果有存入最小运行时间while ((tmp=tmp->next) != NULL) {if (tmp->remainT < minremainT) {minremainT = tmp->remainT;seize = tmp;} else if (minremainT < startProc->remainT && tmp->remainT == minremainT) {if (tmp->arriveT < seize->arriveT)seize = tmp;}}while (index<6) {// 查看在头结点被短进程抢占，或运行结束时，是否有新进程到达if (arrive[index] < (startProc->lastrunT+minremainT)) {node = new ProcInfo;node->procID = index;node->arriveT = arrive[index];node->serverT = server[index];node->remainT = server[index];node->lastrunT = arrive[index];node->runT = 0;node->priority = 0;node->next = NULL;index++;InsertNode(node);// 当有新进程到达时，根据剩余运行时间插入到链表中mid = NULL;tmp = startProc;while (tmp->next != endProc) {if (tmp->next->remainT > endProc->remainT) {mid = tmp;break;}tmp = tmp->next;}if (mid != NULL) {tmp = startProc->next;while (tmp->next != NULL) {if (tmp->next == endProc) {tmp2 = endProc;tmp->next = NULL;endProc = tmp;tmp2->next = mid->next;mid->next = tmp2;break;}tmp = tmp->next;}}// 查看刚插入的结点的剩余运行时间是否小于最小剩余时间if (node->remainT < minremainT) {minremainT = node->remainT;seize = node;} else if (minremainT < startProc->remainT && node->remainT == minremainT) {if (node->arriveT < seize->arriveT)seize = node;}} elsebreak;}// 当seize仍为头结点时，表示没有比头结点更小的剩余运行时间，故移除头结点if (seize == startProc) {RemoveNode();procNum--;} else { // 否则，将抢占进程移到头结点之后，并更改结点tmp = startProc;while (tmp != NULL) {if (tmp->next == seize) {tmp->next = seize->next;if (seize == endProc)endProc = tmp;break;}tmp = tmp->next;}seize->next = startProc->next;if (startProc == endProc)endProc = seize;startProc->next = seize;ChangeNode(minremainT);}} else {if (index<6) {node = new ProcInfo;node->procID = index;node->arriveT = arrive[index];node->serverT = server[index];node->remainT = server[index];node->lastrunT = arrive[index];node->runT = 0;node->priority = 0;node->next = NULL;index++;InsertNode(node);} elsebreak;}}}/*高响应比优先调度算法*/void AlgoHRP(int *arrive,int *server){int procNum=6;int index=0;float waitT,minwaitT,waitT2,lastwaitT;ProcInfo *node,*tmp,*seize,*second;float prio=0,stmp;startProc = endProc = NULL;while(procNum) {if (startProc != NULL) {tmp = seize = second = startProc;minwaitT = startProc->remainT;// 计算在头结点剩余时间内，是否有进程的优先级超过头结点，如果有，取最先超过头结点的进程为抢占进程while((tmp=tmp->next) != NULL) {waitT = (startProc->priority-1)*tmp->serverT+0.1; // 计算超过头结点的最小等待时间lastwaitT = waitT-(startProc->lastrunT-tmp->arriveT-tmp->runT); // 计算头结点运行期间还需要等待的时间if (lastwaitT < minwaitT) { // 当小于最小时间时，更新最小时间，优先级，和抢占进程minwaitT = lastwaitT;tmp->priority = waitT/tmp->serverT+1;seize = tmp;} else if (minwaitT < startProc->remainT && lastwaitT == minwaitT) { // 当等于最小时间时，服务时间越小，优先级越高if (tmp->serverT < seize->serverT) {tmp->priority = waitT/tmp->serverT+1;seize = tmp;} else if (tmp->serverT == seize->serverT) { // 当等于最小时间，服务时间也相同时，先到达者优先if (tmp->arriveT < seize->arriveT) {tmp->priority = waitT/tmp->serverT+1;seize = tmp;}}} else {if (minwaitT == startProc->remainT) { // 当头结点剩余时间内，没有进程的优先级抢占时，计算优先级第二高的进程waitT2 = startProc->lastrunT-tmp->arriveT-tmp->runT+startProc->remainT;stmp = waitT2/tmp->serverT+1;if (stmp>prio) {tmp->priority = prio = stmp;second = tmp;}}}}while (index<6) { // 查看在头结点的剩余时间内，或被抢占的时间间隔内，是否有进程到达if (arrive[index] < (startProc->lastrunT+minwaitT)) {node = new ProcInfo;node->procID = index;node->arriveT = arrive[index];node->serverT = server[index];node->remainT = server[index];node->lastrunT = arrive[index];node->runT = 0;node->priority = 1;node->next = NULL;index++;InsertNode(node);// 查看在该进程到达，到头结点运行结束，或被抢占前，优先级是否能超过头结点waitT = (startProc->priority-1)*node->serverT+0.1;lastwaitT = waitT+(node->arriveT-startProc->lastrunT);if (lastwaitT < minwaitT) {minwaitT = lastwaitT;node->priority = waitT/node->serverT+1;seize = node;} else if (minwaitT < startProc->remainT && lastwaitT == minwaitT) {if (node->serverT < seize->serverT) {node->priority = waitT/node->serverT+1;seize = node;} else if (node->serverT == seize->serverT) {if (node->arriveT < seize->arriveT) {node->priority = waitT/node->serverT+1;seize = node;}}} else {if (minwaitT == startProc->remainT) {waitT2 = startProc->remainT-(node->arriveT-startProc->lastrunT);stmp = waitT2/node->serverT+1;if (stmp > prio) {node->priority = prio = stmp;second = node;}}}} elsebreak;}// 当计算的抢占结点仍为头结点时，表示没有抢占的进程，故将第二高优先级的进程移到头结点之后，并移除头结点if (seize == startProc) {if (second != startProc) {tmp = startProc;while (tmp != NULL) {if (tmp->next == second) {tmp->next = second->next;if (second == endProc)endProc = tmp;break;}tmp = tmp->next;}second->next = startProc->next;if (startProc == endProc)endProc = second;startProc->next = second;}RemoveNode();procNum--;} else { // 当计算的抢占结点不为头结点时，表示存在能够抢占的进程，故将该抢占进程移到头结点之后，并更改结点tmp = startProc;while (tmp != NULL) {if (tmp->next == seize) {tmp->next = seize->next;if (seize == endProc)endProc = tmp;break;}tmp = tmp->next;}seize->next = startProc->next;if (startProc == endProc)endProc = seize;startProc->next = seize;ChangeNode(minwaitT);}} else {if (index<6) {node = new ProcInfo;node->procID = index;node->arriveT = arrive[index];node->serverT = server[index];node->remainT = server[index];node->lastrunT = arrive[index];node->runT = 0;node->priority = 1;node->next = NULL;index++;InsertNode(node);} elsebreak;}}}return 0;}。

进程调度算法实现代码(操作系统)

进程调度算法实现//数据：进程，队列结构//处理流程：//1 初始化--进程队列结构（包括：就绪队列，等待队列，运行队列）等必要的数据结构init(); //2 进入无限循环，反复调度队列#define MAX 5#include<stdio.h>#include<stdlib.h>int total_time=20;int time_slice=3;typedef struct process { // 进程控制块char pname[10];int WaitTime;int BurstTime;int priority; // 数字越小优先级越高struct process *next;}PROCESS;//typedef struct process PROCESS;PROCESS * in_queue(PROCESS *head,PROCESS *p); //声明PROCESS *init() //进程初始化{int i=0;char a;PROCESS *head_new; //队列的队头head_new=(struct process*)malloc(sizeof(struct process));if(!head_new) exit(1);head_new=NULL;do{struct process *s;printf("initialize the process:\n");s=(struct process *)malloc(sizeof(struct process));if(!s) exit(1);printf("please input the pname:WaitTime: BurstTime: priority:\n");scanf("%c",&(s->pname));scanf("%d",&(s->WaitTime));scanf("%d",&(s->BurstTime));scanf("%d",&(s->priority));s->next=NULL;in_queue(head_new,s);i++;printf("do u want to insert process more ?? 'Y'or'N'\n");printf("----------------------------------------'\n");scanf("%c",&a);scanf("%c",&a);// if(a=='Y'||a=='y') continue;// else if(a=='N'||a=='n') break;}while((i<MAX) &&(a=='Y'||a=='y'));return head_new;}///////////////////////////////////////////////////////////PROCESS *in_queue(PROCESS *head,PROCESS *p) //入队函数 {if(head==NULL){head=p;p->next=NULL;}else{p->next=head;head=p;}// printf("the process insert into the mothball queue :\n");return head;}//////////////////////////////////////////////////////////////*void new_queue() //后备队列先来先服务方式进入就绪{return *head_new;}*/PROCESS *FCFS_process(){PROCESS *p,*q,*a; //a用来记录选中结点的前一个结点q=p=init(); //这里是不是有个问题？？while(p->next!=NULL){a=p;if(p->WaitTime>=q->WaitTime){q=p;p=p->next;}}q->WaitTime--;if(q->WaitTime==0) //如果等待时间为0则把该进程从后备队列中移除{a->next=p->next;free(p);}return q; //选择等待时间最久的）}//////////////////////就绪队列，入口函数为就绪队列的头指针/////////////int count=0;PROCESS *ready_queue(PROCESS *head) //就绪队列优先级进入运行4道 {PROCESS *p;while(count<4){p=FCFS_process();p->next=head->next;head=p;count++;printf("the process has inserted into the ready queue :\n"); }return head;}//insert_ready() //PROCESS *high_priority(PROCESS *P) //选择优先级最高的进程 {PROCESS *q,*p; //问题，入口形参中q=p;while(p->next!=NULL){if(q->priority>p->priority)q=p;p=p->next;}return q;}PROCESS *pick_ready(PROCESS *a) //从就绪队列中选择进程运行 {PROCESS *p=ready_queue(a);PROCESS *b=high_priority(p);return b;}void run(PROCESS *a) //运行一个时间片{while((time_slice>0)&&(a->BurstTime>0)) //指针用-> 变量用. {printf("the process %c is runing",a->pname);printf("the process BurstTime time is %d ",a->WaitTime);printf("the process BurstTime time is %d ",a->BurstTime);printf("the process priority is %d ",a->priority);a->BurstTime--;time_slice--;}a->priority--;total_time--;/*if(a->runtime>0)return a;else return NULL;*/}void main(){PROCESS *p;PROCESS *head=init();while(total_time!=0) {ready_queue(head); p=pick_ready(head);if(p->BurstTime==0) {p=p->next;free(p);count--;}run(p);time_slice=3;}}。

操作系统进程调度仿真程序源码

import java.util.*;public class PCB{int priority; //优先级Date createTime,startTime,finishTime; //提交时间，开始时间，完成时间String create,start,finish;int id,runTime,counter=0; //进程ID，运行耗时，运行计时long l1,l2;double perTime;public PCB(){Date createTime=new Date();l2=createTime.getTime();create=String.format("%tT",createTime);priority=(int)(Math.random()*10+1);runTime=(int)(Math.random()*56+5);}public PCB(int runTime,int priority){Date createTime=new Date();l2=createTime.getTime();create=String.format("%tT",createTime);this.priority=priority;this.runTime=runTime;}public void inputID(int id){this.id=id;}public void inputStartTime(Date startTime){this.startTime=startTime;start=String.format("%tT",startTime);}public void inputFinishTime(Date finishTime){this.finishTime=finishTime;l1=finishTime.getTime();finish=String.format("%tT",finishTime);}public void inputCounter(int counter){this.counter=counter;}public int getID(){return id;}public int getPriority(){return priority;}public String getCreateTime(){return create;}public int getRunTime(){return runTime;}public String getStartTime(){return start;}public String getFinishTime(){return finish;}public double getPerTime(){perTime=(l1-l2)/(runTime*1000.0);return perTime;}public int getCounter(){return counter;}public Date getFromTime(){return createTime;}}//------------------------------------------------------------------------------------------------------import javax.swing.*;import java.awt.*;import java.awt.event.*;import javax.swing.table.*;import java.util.*;import java.io.*;public class MainClass implements ActionListener{int pri=5; //存放所选择的优先级String item; //存放所选择的模式V ector<String> nm1,nm2,nm3,nm4; //各个表头信息V ector<PCB> allData=new Vector<PCB>(); //存放生成的所有对象V ector<Object> runData=new Vector<Object>(); //运行进程显示数据V ector<Object> readyData=new Vector<Object>(); //就绪队列显示数据V ector<Object> waitData=new Vector<Object>(); //阻塞队列显示数据V ector<Object> finishData=new Vector<Object>(); //完成队列显示数据V ector<Object> FCFS=new Vector<Object>(); //先来先服务V ector<Object> PF=new Vector<Object>(); //静态优先级调度V ector<Object> DPF=new Vector<Object>(); //动态优先级调度V ector<Object> SJF=new Vector<Object>(); //最短作业优先V ector<Object> SRTF=new Vector<Object>(); //最短剩余时间优先static int id=0;int times=0; //打印运行结果次数boolean active=true,stop; //运行与暂停标志，阻塞与否标志JFrame frame;JLabel jl1,jl2,jl3,jl4,jl5,jl6,jl7,jl8;JScrollPane jsp0,jsp1,jsp2,jsp3;JTextField now,tm;JComboBox mode,priorityBox;JButton createprocess,interrupt,controll,wakeup,save,exit;MTable runprocess,ready,interrupted,finish;public MainClass(){frame=new JFrame("进程调度仿真——3118310_池毓兴&&1928105_王慧娟");frame.setSize(800,650);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);Container c=frame.getContentPane();c.setLayout(null);c.setBounds(0,0,800,600);jl1=new JLabel("当前时间：");jl1.setForeground(Color.red);jl1.setBounds(10,10,70,20);c.add(jl1);now=new JTextField(5);Thread thread0=new Thread(new Runnable(){public void run(){try{while(true){Date time=new Date();String nowtime=String.format("%tT",time);now.setText(nowtime);Thread.sleep(1000);}}catch(InterruptedException e) {e.printStackTrace();}}});thread0.start();now.setEditable(false);now.setBackground(Color.black);now.setForeground(Color.green);now.setBounds(80,10,60,20);c.add(now);jl2=new JLabel("调度模式：");jl2.setForeground(Color.red);c.add(jl2);jl2.setBounds(280,10,70,20);String items[]={"先来先服务算法","静态优先级调度算法","动态优先级调度算法","最短作业优先算法","最短剩余时间优先算法"};mode=new JComboBox(items);mode.setSelectedIndex(0);mode.addItemListener(new ModeChoice());mode.setEditable(false);mode.setSize(2,18);c.add(mode); //调度模式设置mode.setBounds(350,10,150,20);jl4=new JLabel("优先级选择：");jl4.setForeground(Color.red);jl4.setBounds(10,35,90,20);c.add(jl4);Object itm[]={1,2,3,4,5,6,7,8,9,10};priorityBox=new JComboBox(itm);priorityBox.setSelectedIndex(4);priorityBox.addItemListener(new ItemListener(){public void itemStateChanged(ItemEvent e){String stri=e.getItem().toString();pri=Integer.parseInt(stri);}});priorityBox.setEditable(false);priorityBox.setBounds(100,35,50,20);c.add(priorityBox); //优先级输入jl3=new JLabel("运行耗时：");jl3.setForeground(Color.red);jl3.setBounds(280,35,70,20);c.add(jl3);tm=new JTextField(5);tm.setBounds(350,35,150,20);c.add(tm); //运行耗时输入createprocess=new JButton("创建进程");createprocess.setBounds(650,35,100,25);c.add(createprocess);createprocess.addActionListener(this); //监听器controll=new JButton(); //进程控制if(active)controll.setText("暂停运行");elsecontroll.setText("开始运行");controll.setBounds(650,5,100,25);c.add(controll);controll.addActionListener(this); //监听器jl8=new JLabel("当前进程：");jl8.setForeground(Color.red);jl8.setBounds(10,60,150,20);c.add(jl8);//-----------------------------运行进程JTableString[] name1={"进程ID","优先级","提交时间","运行耗时","开始时间","运行计时"};nm1=new Vector<String>();for(int column=0;column<name1.length;column++){nm1.add(name1[column]);}runprocess=new MTable(runData,nm1);// runprocess.setPreferredScrollableViewportSize(new Dimension(500,50));// runprocess.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);runprocess.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);runprocess.setSelectionBackground(Color.yellow);runprocess.setSelectionForeground(Color.red);// runprocess.setRowHeight(30);jsp0=new JScrollPane();jsp0.setViewportView(runprocess);jsp0.setBounds(10,85,600,37);c.add(jsp0);interrupt=new JButton("阻塞进程");//阻塞控制interrupt.setBounds(650,95,100,25);c.add(interrupt);interrupt.addActionListener(this);jl5=new JLabel("就绪队列：");jl5.setForeground(Color.red);jl5.setBounds(10,140,70,20);c.add(jl5);//---------------------------就绪队列JTableString name2[]={"进程ID","优先级","提交时间","运行耗时","已运行"};nm2=new Vector<String>();for(int column=0;column<name2.length;column++){nm2.add(name2[column]);}ready=new MTable(readyData,nm2);// DefaultTableModel model2 = new DefaultTableModel();// ready.setmodel(model2);// ready.setPreferredScrollableViewportSize(new Dimension(500,100));// ready.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);ready.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);ready.setSelectionBackground(Color.yellow);ready.setSelectionForeground(Color.red);// ready.setRowHeight(30);jsp1=new JScrollPane();jsp1.setViewportView(ready);jsp1.setBounds(10,165,600,100);c.add(jsp1);jl6=new JLabel("阻塞队列：");jl6.setForeground(Color.red);jl6.setBounds(10,280,70,20);c.add(jl6);//------------------------------------阻塞队列JTableString name3[]={"进程ID","优先级","提交时间","运行耗时","开始时间","已运行"};nm3=new Vector<String>();for(int column=0;column<name3.length;column++){nm3.add(name3[column]);}interrupted=new MTable(waitData,nm3);// interrupted.setPreferredScrollableViewportSize(new Dimension(440,80));// interrupted.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);interrupted.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);interrupted.setSelectionBackground(Color.yellow);interrupted.setSelectionForeground(Color.red);// interrupted.setRowHeight(30);jsp2=new JScrollPane();jsp2.setViewportView(interrupted);jsp2.setBounds(10,305,600,80);c.add(jsp2);wakeup=new JButton("唤醒进程"); //唤醒控制wakeup.setBounds(650,325,100,25);c.add(wakeup);wakeup.addActionListener(this);jl7=new JLabel("完成队列：");jl7.setForeground(Color.red);jl7.setBounds(10,400,70,20);c.add(jl7);//---------------------------------------完成队列JTableString name4[]={"进程ID","优先级","提交时间","运行耗时","开始时间","完成时间","带权周转时间"};nm4=new Vector<String>();for(int column=0;column<name4.length;column++){nm4.add(name4[column]);}finish=new MTable(finishData,nm4);// finish.setPreferredScrollableViewportSize(new Dimension(500,120));// finish.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);finish.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);finish.setSelectionBackground(Color.yellow);finish.setSelectionForeground(Color.red);// finish.setRowHeight(30);jsp3=new JScrollPane();jsp3.setViewportView(finish);jsp3.setBounds(10,425,600,120);c.add(jsp3);save=new JButton("保存结果");save.setBounds(250,580,100,25);c.add(save);save.addActionListener(this);exit=new JButton("退出系统");exit.setBounds(400,580,100,25);c.add(exit);exit.addActionListener(this);c.setVisible(true);frame.setVisible(true);new ThreadRunning().start(); //线程启动new Looking().start();}//--------------------------------------------------------------------------------------------------------------- public int outputruntime(){ //从输入框获取运行时间String s=tm.getText();int rt;if(s.trim().length()==0)return 0;else{try{rt=Integer.parseInt(s);return rt;}catch(NumberFormatException e){System.out.println("您没有输入数值数据！");return 0;}}}//-------------------------------------------------------------------------------------------class ModeChoice implements ItemListener{public void itemStateChanged(ItemEvent e){item=e.getItem().toString();}}@SuppressWarnings("unchecked")public void operation(){ //进程调度核心算法：PF,SRTF,MLFQ的计算Vector<Object> up=new Vector<Object>();Vector<Object> temp=new Vector<Object>();Vector<Object> bridge=new V ector<Object>();Vector<Object> cloneData=new Vector<Object>();int max,maxp,midp;cloneData=(Vector)FCFS.clone();for(int i=0;i<cloneData.size();i++){temp=(V ector)cloneData.get(0);maxp=(Integer)temp.get(1);max=0;for(int j=1;j<cloneData.size()-i;j++){temp=(V ector)cloneData.get(j);midp=(Integer)temp.get(1);if(maxp>midp){max=j;maxp=midp;}}up=(V ector)cloneData.get(max);bridge=(Vector)cloneData.get(cloneData.size()-i-1);cloneData.setElementAt(up,cloneData.size()-i-1);cloneData.setElementAt(bridge,max);}PF=cloneData;DPF=cloneData;cloneData=(Vector)FCFS.clone();for(int i=0;i<cloneData.size();i++){temp=(V ector)cloneData.get(0);maxp=(Integer)temp.get(3)-(Integer)temp.get(4);max=0;for(int j=1;j<cloneData.size()-i;j++){temp=(V ector)cloneData.get(j);midp=(Integer)temp.get(3)-(Integer)temp.get(4);if(maxp<midp){max=j;maxp=midp;}}up=(V ector)cloneData.get(max);bridge=(Vector)cloneData.get(cloneData.size()-i-1);cloneData.setElementAt(up,cloneData.size()-i-1);cloneData.setElementAt(bridge,max);}SJF=cloneData;cloneData=(Vector)FCFS.clone();for(int i=0;i<cloneData.size();i++){temp=(Vector)cloneData.get(0);maxp=(Integer)temp.get(3)-(Integer)temp.get(4);max=0;for(int j=1;j<cloneData.size()-i;j++){temp=(V ector)cloneData.get(j);midp=(Integer)temp.get(3)-(Integer)temp.get(4);if(maxp<midp){max=j;maxp=midp;}}up=(V ector)cloneData.get(max);bridge=(Vector)cloneData.get(cloneData.size()-i-1);cloneData.setElementAt(up,cloneData.size()-i-1);cloneData.setElementAt(bridge,max);}SRTF=cloneData;}@SuppressWarnings("unchecked")public void addrunData(){Vector<Object> temp1=new Vector<Object>(6);Vector<Object> tp=new Vector<Object>();if(readyData.size()!=0){// temp1=readyData.ElementAt(0);// temp1=readyData.firstElement();// temp1=readyData.get(0); //三种获取元素的方法if(readyData.firstElement() instanceof Vector){tp=(Vector)readyData.get(0);}for(int i=0;i<tp.size();i++)temp1.add(tp.get(i));Integer ide=(Integer)temp1.get(0);readyData.removeElementAt(0);for(int i=0;i<FCFS.size();i++){tp=(V ector)FCFS.get(i);Integer iden=(Integer)tp.get(0);if(iden==ide){FCFS.removeElementAt(i);operation();break;}}PCB pro=new PCB();if(allData.get(ide) instanceof PCB){pro=(PCB)allData.get(ide);}String st=new String();int lastT=(Integer)temp1.get(4);if(lastT==0){Date startTime=new Date();pro.inputStartTime(startTime);st=pro.getStartTime();}else{st=pro.getStartTime();}// pro.inputStartTime(startTime);// st=pro.getStartTime();temp1.insertElementAt(st,4);runData.clear();runData.addElement(temp1);}else{// JOptionPane.showMessageDialog(null, "就绪队列为空，运行结束！", "注意",JOptionPane.W ARNING_MESSAGE);}}public void addreadyData(){try{if(item.equals("先来先服务算法")){readyData.clear();for(int i=0;i<FCFS.size();i++){readyData.add(FCFS.get(i));}}else if(item.equals("静态优先级调度算法")){readyData.clear();for(int i=0;i<PF.size();i++){readyData.add(PF.get(i));}}else if(item.equals("动态优先级调度算法")){readyData.clear();for(int i=0;i<PF.size();i++){readyData.add(DPF.get(i));}}else if(item.equals("最短作业优先算法")){readyData.clear();for(int i=0;i<SJF.size();i++){readyData.add(SJF.get(i));}}else if(item.equals("最短剩余时间优先算法")){readyData.clear();for(int i=0;i<SRTF.size();i++){readyData.add(SRTF.get(i));}}}catch(NullPointerException m){System.out.println("");}}//-------------------------------------------------------------------public class ThreadRunning extends Thread{ //主线程操作@SuppressWarnings("unchecked")public void run(){try{while(true){V ector<Object> temp2=new Vector<Object>();while(runData.isEmpty()){addrunData();}temp2=(Vector)runData.get(0);while(!active); //暂停处理sleep(900);Integer r=(Integer)temp2.get(3);Integer n=(Integer)temp2.get(5);if(n>=r){String ft=new String();Integer ide=(Integer)temp2.get(0);Date finishTime=new Date();PCB proc;proc=(PCB)allData.get(ide);proc.inputFinishTime(finishTime);ft=proc.getFinishTime();Double pt=new Double(proc.getPerTime());temp2.setElementAt(ft,5);temp2.addElement(pt);finishData.addElement(temp2);runData.clear();addrunData();}else if(stop){ //阻塞处理waitData.add(temp2);runData.clear();addrunData();stop=false;}else{if(item.equals("最短剩余时间优先算法")){if(readyData.isEmpty()){n++;temp2.setElementAt(n,5);runData.clear();runData.add(temp2);}else{Vector rd=new V ector();rd=(Vector)readyData.get(0);int sx=(Integer)rd.get(3)-(Integer)rd.get(4);if(sx<(r-n)){temp2.removeElementAt(4);FCFS.add(temp2);operation();addrunData();}else{n++;temp2.setElementAt(n,5);runData.clear();runData.add(temp2);}}}else if(item.equals("静态优先级调度算法")){if(readyData.isEmpty()){n++;temp2.setElementAt(n,5);runData.clear();runData.add(temp2);}else{Vector rd=new Vector();rd=(Vector)readyData.get(0);int py=(Integer)rd.get(1);int pty=(Integer)temp2.get(1);if(pty<py){temp2.removeElementAt(4);FCFS.add(temp2);operation();addrunData();}else{n++;temp2.setElementAt(n,5);runData.clear();runData.add(temp2);}}}else if(item.equals("动态优先级调度算法")){int pty=(Integer)temp2.get(1);if(readyData.isEmpty()){if(n%15==0&&n!=0){if(pty>1){pty--;temp2.setElementAt(pty,1);}}n++;temp2.setElementAt(n,5);runData.clear();runData.add(temp2);}else{if(n%15==0&&n!=0){if(pty>1){pty--;temp2.setElementAt(pty,1);}Vector tempx=new Vector();for(int i=0;i<FCFS.size();i++){tempx=(Vector)FCFS.get(i);int pp=(Integer)tempx.get(1);if(pp<10){pp++;tempx.setElementAt(pp,1);FCFS.setElementAt(tempx,i);}}operation();}else{};Vector rd=new Vector();rd=(Vector)readyData.get(0);pty=(Integer)temp2.get(1);int py=(Integer)rd.get(1);if(pty<py){n++;temp2.setElementAt(n,5);temp2.removeElementAt(4);FCFS.add(temp2);operation();addrunData();}else{n++;temp2.setElementAt(n,5);runData.clear();runData.add(temp2);}}}else{n++;temp2.setElementAt(n,5);runData.clear();runData.add(temp2);}}}}catch(InterruptedException e) {e.printStackTrace();}}}//--------------------------------------------------------------------------------------------------------- public class Looking extends Thread{ //监视程序public void run(){try{while(true){addreadyData(); //时刻监视就绪队列动静sleep(1000);item=(String)mode.getSelectedItem();jsp0.setViewportView(runprocess);jsp1.setViewportView(ready);jsp2.setViewportView(interrupted);jsp3.setViewportView(finish);if(active){controll.setText("暂停运行");}else{controll.setText("开始运行");}}}catch(InterruptedException e) {e.printStackTrace();}}}public void actionPerformed(ActionEvent e){ //事件响应if(e.getSource()==createprocess){CreateProcess();}else if(e.getSource()==exit){closeOperation();}else if(e.getSource()==save){save();}else if(e.getSource()==wakeup){wakeup();}else if(e.getSource()==interrupt){if(runData.isEmpty()){JOptionPane.showMessageDialog(null, "没有运行进程，阻塞失败！", "注意",JOptionPane.W ARNING_MESSAGE);}else{stop=true;}}else if(e.getSource()==controll){if(active){active=false;controll.setText("开始运行");}else{active=true;controll.setText("暂停进程");}}}@SuppressWarnings("unchecked")public void wakeup(){Vector<Object> temp=new Vector<Object>();int selected=0,ident=-1,identy=-1;selected=interrupted.getSelectedRow();if(selected<=-1||selected>=waitData.size())JOptionPane.showMessageDialog(null, "请先选择要唤醒的进程！", "警告",JOptionPane.W ARNING_MESSAGE);else{ident=(Integer)interrupted.getValueAt(selected,0);for(int i=0;i<waitData.size();i++){temp=(Vector)waitData.get(i);identy=(Integer)temp.get(0);if(ident==identy){waitData.removeElementAt(i);break;}}temp.removeElementAt(4);FCFS.addElement(temp);operation();}}public void closeOperation(){if(times==0){Object[] options = {"是","否","取消"};int response=JOptionPane.showOptionDialog(null, "您还未保存结果，是否保存后再退出系统？", "友情提示",JOptionPane.YES_OPTION,JOptionPane.QUESTION_MESSAGE,null,options,options[0]);if(response==0){save();frame.dispose();}else if(response==1){frame.dispose();}else if(response==2){}}else{frame.dispose();}}public void save(){String str=new String();String f=new String();times++;for(int i=0;i<finish.getColumnCount();i++)str=str+" "+finish.getColumnName(i);for(int i=0;i<finish.getRowCount();i++){str=str+"\n";for(int j=0;j<finish.getColumnCount();j++){str=str+" "+finish.getValueAt(i,j).toString();}}f="王慧娟_1928105_Result"+String.valueOf(times)+".txt";try{File file=new File(f);FileWriter result=new FileWriter(file);result.write(str);result.close();}catch(IOException e){JOptionPane.showMessageDialog(null, "对不起，结果保存失败！", "保存提示",JOptionPane.W ARNING_MESSAGE);}JOptionPane.showMessageDialog(null, "恭喜您，运行结果已保存至相同路径下的<王慧娟>txt文件中！", "保存提示",RMATION_MESSAGE);}//-----------------------------------------------------------------------------public void CreateProcess(){ //创建进程PCB process;Vector<Object> temp=new Vector<Object>();int runT;runT=outputruntime();if(runT<=0){process=new PCB();process.inputID(id);id++;}else{process=new PCB(runT,pri);process.inputID(id);id++;}allData.addElement(process);Integer id=new Integer(process.getID());Integer priority=new Integer(process.getPriority());String createTime=new String(process.getCreateTime());Integer runTime=new Integer(process.getRunTime());Integer counter=new Integer(process.getCounter());temp.addElement(id);temp.addElement(priority);temp.addElement(createTime);temp.addElement(runTime);temp.addElement(counter);FCFS.addElement(temp);operation();}//--------------------------------------------------------------------------------private class MTable extends JTable{ //表格设置/****/private static final long serialVersionUID = 1L;public MTable(Vector<Object> rowData,Vector<String> columnNames){ super(rowData,columnNames);}public JTableHeader getTableHeader(){JTableHeader tableHeader=super.getTableHeader();tableHeader.setReorderingAllowed(false);DefaultTableCellRendererhr=(DefaultTableCellRenderer)tableHeader.getDefaultRenderer();hr.setHorizontalAlignment(DefaultTableCellRenderer.CENTER);return tableHeader;}public TableCellRenderer getDefaultRenderer(Class<?> columnClass){DefaultTableCellRenderercr=(DefaultTableCellRenderer)super.getDefaultRenderer(columnClass);cr.setHorizontalAlignment(DefaultTableCellRenderer.CENTER);return cr;}public boolean isCellEditable(int row,int column){return false;}}}//--------------------------------------------------------------------------------------------------------import javax.swing.*;import java.awt.*;import java.awt.event.*;import javax.swing.table.*;import java.util.*;import java.io.*;public class MainProgramme implements ActionListener{int pri=5; //存放所选择的优先级String item; //存放所选择的模式int flag=0; //当前运行进程是从flag级就绪队列获得V ector<String> nm,nm1,nm2,nm3,nm4; //各个表头信息V ector<PCB> allData=new Vector<PCB>(); //存放生成的所有对象V ector<Object> runData=new Vector<Object>(); //运行进程显示数据V ector<Object> readyData1=new Vector<Object>(); //高优先级就绪队列显示数据V ector<Object> readyData2=new Vector<Object>(); //中优先级就绪队列显示数据V ector<Object> readyData3=new Vector<Object>(); //低优先级就绪队列显示数据V ector<Object> waitData=new Vector<Object>(); //阻塞队列显示数据V ector<Object> finishData=new Vector<Object>(); //完成队列显示数据V ector<Object> RR=new Vector<Object>(); //静态时间片轮转法V ector<Object> DRR=new Vector<Object>(); //动态时间片轮转法V ector<Object> MLFQ=new Vector<Object>(); //多级反馈队列调度算法static int id=0;int times=0; //打印运行结果次数boolean active=true; //运行与暂停标志int king=-1; //定时进程到时标志boolean Unstop=false; //king is running !boolean kill=false; //阻止监视线程的运行JFrame frame;JLabel jl1,jl2,jl3,jl4,jl5,jl6,jl7,jl8,jl9,jl10,jl11;JScrollPane jsp0,jsp1,jsp2,jsp3,jsp4,jsp5;JTextField now,tm,start;JComboBox mode,priorityBox;JButton createprocess,controll,save,exit;MTable runprocess,ready1,ready2,ready3,interrupted,finish;public MainProgramme(){frame=new JFrame("进程调度仿真——3118310_池毓兴&&1928105_王慧娟");frame.setSize(800,700);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);Container c=frame.getContentPane();c.setLayout(null);c.setBounds(0,0,800,650);jl1=new JLabel("当前时间：");jl1.setForeground(Color.red);jl1.setBounds(10,10,70,20);c.add(jl1);now=new JTextField(5);Thread thread0=new Thread(new Runnable(){public void run(){try{while(true){Date time=new Date();String nowtime=String.format("%tT",time);now.setText(nowtime);Thread.sleep(1000);}}catch(InterruptedException e) {e.printStackTrace();}}});thread0.start();now.setEditable(false);now.setBackground(Color.black);now.setForeground(Color.green);now.setBounds(80,10,60,20);c.add(now);jl2=new JLabel("调度模式：");jl2.setForeground(Color.red);c.add(jl2);jl2.setBounds(280,10,70,20);String items[]={"静态时间片轮转法","动态时间片轮转法","多级反馈调度算法"}; mode=new JComboBox(items);mode.setSelectedIndex(0);mode.addItemListener(new ModeChoice());mode.setEditable(false);mode.setSize(2,18);c.add(mode); //调度模式设置mode.setBounds(350,10,150,20);jl4=new JLabel("优先级选择：");jl4.setForeground(Color.red);jl4.setBounds(10,35,90,20);c.add(jl4);Object itm[]={1,2,3,4,5,6,7,8,9,10};priorityBox=new JComboBox(itm);priorityBox.setSelectedIndex(4);priorityBox.addItemListener(new ItemListener(){public void itemStateChanged(ItemEvent e){String stri=e.getItem().toString();pri=Integer.parseInt(stri);}});priorityBox.setEditable(false);priorityBox.setBounds(100,35,50,20);c.add(priorityBox); //优先级输入jl3=new JLabel("运行耗时：");jl3.setForeground(Color.red);jl3.setBounds(200,35,70,20);c.add(jl3);tm=new JTextField(5);tm.setBounds(270,35,80,20);c.add(tm); //运行耗时输入jl11=new JLabel("开始时间：");jl11.setForeground(Color.red);jl11.setBounds(400,35,70,20);c.add(jl11);start=new JTextField(5);start.setBounds(470,35,120,20);c.add(start); //运行耗时输入createprocess=new JButton("创建进程");createprocess.setBounds(650,35,100,25);c.add(createprocess);createprocess.addActionListener(this); //监听器controll=new JButton(); //进程控制if(active)controll.setText("暂停运行");elsecontroll.setText("开始运行");controll.setBounds(650,5,100,25);c.add(controll);controll.addActionListener(this); //监听器jl8=new JLabel("当前进程：");jl8.setForeground(Color.red);jl8.setBounds(50,60,150,20);c.add(jl8);//-----------------------------运行进程JTableString[] name1={"进程ID","优先级","提交时间","运行耗时","开始时间","运行计时","时间片"};nm1=new Vector<String>();for(int column=0;column<name1.length;column++){nm1.add(name1[column]);}runprocess=new MTable(runData,nm1);// runprocess.setPreferredScrollableViewportSize(new Dimension(500,50));// runprocess.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);runprocess.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);runprocess.setSelectionBackground(Color.yellow);runprocess.setSelectionForeground(Color.red);// runprocess.setRowHeight(30);jsp0=new JScrollPane();jsp0.setViewportView(runprocess);jsp0.setBounds(50,85,700,37);。

进程调度算法代码

进程调度算法代码进程调度算法是操作系统中的一种重要机制，它决定了在多道程序环境下，如何安排各个进程的执行顺序和时间片。

不同的进程调度算法有不同的实现方式和优缺点，本文将就常见的几种进程调度算法进行详细介绍。

1. 先来先服务（FCFS）先来先服务是最简单、最直观的进程调度算法。

它按照进程到达时间的先后顺序进行调度，即先到达的进程先执行。

当一个进程开始执行后，直到该进程执行完毕或者发生某些阻塞事件才会切换到另一个进程。

FCFS算法代码如下：```void FCFS(){int i;for(i=0;i<n;i++){run(p[i].need_time);if(i!=n-1){wait(p[i+1].arrive_time-p[i].arrive_time-p[i].need_time); }}}```其中，p数组表示所有需要执行的进程，n表示总共有多少个需要执行的进程。

run函数表示运行该进程所需时间片，wait函数表示等待下一个进程到达所需时间。

FCFS算法优点是简单易懂、公平性好，但其缺点也很明显：无法处理短作业优先问题、平均等待时间长等。

2. 短作业优先（SJF）短作业优先是一种非抢占式的进程调度算法，它根据每个进程的执行时间来进行排序，执行时间短的进程先执行。

如果有多个进程的执行时间相同，则按照到达时间的先后顺序进行调度。

SJF算法代码如下：```void SJF(){int i,j;for(i=0;i<n;i++){for(j=i+1;j<n;j++){if(p[i].need_time>p[j].need_time){swap(p[i],p[j]);}}}for(i=0;i<n;i++){run(p[i].need_time);if(i!=n-1){wait(p[i+1].arrive_time-p[i].arrive_time-p[i].need_time); }}}```其中，swap函数表示交换两个进程的位置。

操作系统进程调度C语言代码

操作系统进程调度C语言代码#include <stdio.h>#define MAX 20//进程控制块typedef struct PCBchar name[10]; // 进程名int AT; // 到达时间int BT; // 服务时间int Pri; // 优先数int FT; // 完成时间int WT; //等待时间int RT; // 响应时间int position; // 第几号进程int flag; // 用来判断进程是否执行过}PCB;//进程调度void schedule(PCB a[], int n, int alg)int i, j, k, flag, temp;int count = 0;int pri_max = 0;float ATAT = 0.0;float AWT = 0.0;float ART = 0.0;PCBt;//各种算法的调度if (alg == 1)printf("采用先来先服务调度：\n"); //根据到达时间执行for (i = 0; i < n; i++)for (j = i + 1; j < n; j++)if (a[i].AT > a[j].AT)t=a[i];a[i]=a[j];a[j]=t;}//按到达时间依次执行for (i = 0; count != n; i++)for (j = 0; j < n; j++)//查找第一个到达时间小于等于当前时间的进程if (a[j].AT <= i && a[j].flag == 0)//记录运行时间a[j].BT--;//如果运行完成，记录完成时间、等待时间、响应时间if (a[j].BT == 0)a[j].FT=i+1;a[j].WT = a[j].FT - a[j].AT - a[j].Pri;a[j].RT=a[j].WT;a[j].flag = 1;count++;}elsebreak;}}}else if (alg == 2)printf("采用最短服务时间优先（非抢占）调度：\n");for (i = 0; count != n; i++)//找出服务时间最短的进程，并将其放置到最前面for (j = 0; j < n; j++)。

2实验二进程调度(优先数调度)参考代码

进程调度算法（优先数调度）一、实验目的用高级语言编写一个模拟进程调度程序，以加深对进程调度和进程调度算法的理解。

二、实验要求编写一个可动态输入进程数，采用优先级调度算法实现，要求：（1）优先数动态变化，每运行一次优先数减1。

（2）使用链表链接进程控制块。

（3）进程运行完要撤销该进程。

三、源程序#include<stdio.h>#include<stdlib.h>#include<conio.h>#define getpch(type) (type *)malloc(sizeof(type))#define NULL 0struct pcb{ /*定义进程控制块*/char name[10]; //进程名char state; //进程状态int super; //优先数int ntime; //总运行时间int rtime; //已运行时间struct pcb *link;}*ready=NULL,*p;typedef struct pcb PCB;sort()//建立对进程优先级排序函数{PCB *first,*second;int insert=0;if((ready==NULL) || ((p->super)>(ready->super)))//优先级最大插入队首{p->link=ready;ready=p;}else//进程比实优先级，插入适当的位置中{first=ready;second=first->link ;while(second!=NULL){if((p->super)>(second->super))//若插入进程比当前进程优先数大{p->link=second;//插入到当前进程前面first->link =p;second=NULL;insert=1;}else//插入进程优先烽最低，则插入到队尾{first=first->link;second=second->link;}}if(insert==0)first->link=p;}}input()//建立进程控制块函数{int i,num;//clrscr()//清屏printf("\n 请输入被调度的进程数目：");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程NO%d：",i);p=getpch(PCB);printf("\n 输入进程名：");scanf("%s",p->name);printf("\n 输入进程优先数：");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);p->rtime=0;p->state='W';p->link=NULL;sort();//调用sort()排序}}int space() //测试进程数{int l=0;PCB *pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp(PCB *pr)//建立进程显示函数，用显示当前进程{printf("\n进程名\t状态\t 优先数\t总运行时间\t已运行时间\n");printf("%s\t",pr->name);printf(" %c\t",pr->state);printf("%5d\t",pr->super);printf("%5d\t",pr->ntime);printf("%12d\t",pr->rtime);printf("\n");}check()//建立进程查看函数{PCB *pr;printf("****当前正在运行的进程是：%s",p->name);//显示当前运行进程disp(p);pr=ready;printf("当前就就绪队列的状态：\n");//显示就绪队列状态while(pr!=NULL){disp(pr);pr=pr->link ;}}destroy()//建立进程撤销函数（进程运行结束,撤销进程){printf("\n进程[%s]已完成。

操作系统五种进程调度算法的代码

操作系统五种进程调度算法的代码一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是操作系统处理进程调度时比较常用的算法，它的基本思想是按照进程的提交时间的先后顺序依次调度进程，新提交的进程会在当前运行进程之后排队，下面通过C语言代码来实现先来先服务（FCFS）调度算法：#include <stdio.h>#include <stdlib.h>//定义进程的数据结构struct Processint pid; // 进程标识符int at; // 到达时间int bt; // 执行时间};//进程调度函数void fcfs_schedule(struct Process *processes, int n)int i, j;//根据进程的到达时间排序for(i = 0; i < n; i++)for(j = i+1; j < n; j++)if(processes[i].at > processes[j].at) struct Process temp = processes[i]; processes[i] = processes[j];processes[j] = temp;//获取各个进程执行完毕的时间int ct[n];ct[0] = processes[0].at + processes[0].bt; for(i = 1; i < n; i++)if(ct[i-1] > processes[i].at)ct[i] = ct[i-1] + processes[i].bt;elsect[i] = processes[i].at + processes[i].bt; //计算各个进程的周转时间和带权周转时间int tat[n], wt[n], wt_r[n];for(i = 0; i < n; i++)tat[i] = ct[i] - processes[i].at;wt[i] = tat[i] - processes[i].bt;wt_r[i] = wt[i] / processes[i].bt;printf("P%d:\tAT=%d\tBT=%d\tCT=%d\tTAT=%d\tWT=%d\tWT_R=%f\n", processes[i].pid, processes[i].at, processes[i].bt, ct[i], tat[i], wt[i], wt_r[i]);//主函数int mainstruct Process processes[] ={1,0,3},{2,3,5},{3,4,6},{4,5,2},{5,6,4}};fcfs_schedule(processes, 5);return 0;输出：。

实验一进程调度模拟算法

实验一进程调度模拟算法
进程调度模拟算法是操作系统中的重要概念，它是指操作系统如何安排进程的执行顺序，以达到最优的系统性能。

常见的进程调度算法包括先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。

下面将分别介绍这些算法的原理和特点。

1. 先来先服务（FCFS）
先来先服务是最简单的进程调度算法，它按照进程到达的先后顺序进行调度，即先到达的进程先执行。

这种算法的优点是实现简单，适用于长作业，但是它存在一个致命的缺陷，即无法处理短作业的情况，因为长作业可能会占用大量的CPU 时间，导致短作业等待时间过长。

2. 短作业优先（SJF）
短作业优先是一种非抢占式的调度算法，它按照进程的执行时间长短进行调度，即执行时间短的进程先执行。

这种算法的优点是可以减少平均等待时间，但是它存在一个问题，即可能会导致长作业一直等待，因为短作业总是可以插队执行。

3. 时间片轮转（RR）
时间片轮转是一种抢占式的调度算法，它将CPU时间划分为若干个时间片，每个进程在一个时间片内执行一定的时间，然后被挂起，让其他进程执行，直到所有进程都执行完毕。

这种算法的优点是可以保证所有进程都能得到执行，但是它存在一个问题，即时间片的长度会影响系统性能，如果时间片太短，会增加上下文切换的开销，如果时间片太长，会导致长作业等待时间过长。

实验一介绍了三种常见的进程调度算法，它们各有优缺点，需要根据具体的应用场景选择合适的算法。

操作系统课程设计进程调度模拟源代码

top=top->next;
runqueue->next=NULL;//从就绪队列选一个节点，插入运行队列
runqueue->killtime=timeslice;//计算消耗的时间
runqueue->runedtime=runqueue->runedtime+runqueue->killtime;//计算总共运行时间
return 0;
}
printf("kill name %d, runtime=%d, runedtime=%d,killtime=%d\n"
,runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
n++;
delete(runqueue);
,runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
}
else if(runqueue->runtime<=0){//判断是否结束
runqueue->killtime=0;
runqueue->runtime=0;
else if(top_wait->next!=NULL){//
p=top_wait;
while(p->next!=temp){
p=p->next;
}
if(temp==tail_wait)
tail_wait=p;
p->next=temp->next;

操作系统进程调度算法模拟

实验一进程调度算法模拟一.实验题目：设计一个简单的进程调度算法，模拟OS中的进程调度过程二．要求：①进程数不少于5个；②进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③用C语言编程；④程序运行时显示进程调度过程。

三．程序中所用数据结构及说明:进程控制块结构体：typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片}Block,pcb;就绪进程链表节点：typedef struct node2{pcb data;struct node2 *next;}process;四．清单程序及描述：Procelink.h:typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片//char STATE;//进程状态//struct node *next;//进程队列指针}Block,pcb;typedef struct node2{pcb data;struct node2 *next;}process;void Initlink(process **PQ){/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*PQ = (process *)malloc(sizeof(process))) == NULL) exit(1);(*PQ)->next = NULL; /*置链尾标记NULL */}int IsEmpty(process *PQ){if(PQ->next == NULL)return 1;else return 0;}void EnInitlink(process *PQ,pcb p){while(PQ->next!=NULL) PQ=PQ->next;process *temp=(process *)malloc(sizeof(Block));temp->data.PRIORITY=p.PRIORITY;temp->data.ID=p.ID;temp->data.CPUTIME=p.CPUTIME;temp->data.ALLTIME=p.ALLTIME;temp->next=PQ->next;PQ->next=temp;}//插入pcb DeInitlink(process *PQ) //选择优先数最小的出列{if(IsEmpty(PQ)){printf("所有进程已运行完!\n");exit(0);//退出}process *temp=(process *)malloc(sizeof(Block));temp = PQ->next;process *te=(process *)malloc(sizeof(Block));process *t=(process *)malloc(sizeof(Block));te= PQ->next;//优先数最小的进程while(temp->next != NULL){if(te->data.PRIORITY<temp->next->data.PRIORITY){te=temp->next;t=temp->next->next;PQ=temp;}temp=temp->next;}PQ->next=PQ->next->next;pcb pp=te->data;// free(temp);// free(t);//free(te);return pp;}//出队列void outid(process *PQ)//输出就绪队列函数{ printf("当前就绪队列为: ");while(!IsEmpty(PQ)){printf("%d ",PQ->next->data.ID);PQ=PQ->next;}printf("\n");}void dispatch(pcb p,process *PQ)//进程运行函数{if((p.ALLTIME)!=0){p.PRIORITY-=3;p.CPUTIME+=1;p.ALLTIME-=1;printf("进程%d运行\n",p.ID);//printf("进程优先数：%d 进程已占用时间片：%d 进程还需占用时间片：%d\n",p.PRIORITY,p.CPUTIME,p.ALLTIME);outid(PQ);//输出就绪队列}if((p.ALLTIME)==0){printf("进程%d 运行完成!\n",p.ID);return;//完成则不加入链表}EnInitlink(PQ,p); return;//运行之后再加入链表}os_1.cpp:#include<stdio.h>#include<stdlib.h>#include"procelink.h"void main(){process * PQ;int n;//n为进程数pcb pro1;Initlink(& PQ);printf("请输入进程个数：");scanf("%d",&n);printf("请输入各个进程的进程标识数ID,进程优先数，进程已占用时间片，进程还需占用时间片\n");for(int i=1;i<=n;i++){printf("第%d进程: ",i);scanf("%d %d %d %d",&pro1.ID,&pro1.PRIORITY,&pro1.CPUTIME,&pro1.ALLTIME);EnInitlink(PQ,pro1);}while(!IsEmpty(PQ)){dispatch(DeInitlink(PQ),PQ);//进程运行函数调用}if(IsEmpty(PQ))printf("所有进程已运行完!\n");free(PQ);//释放内存空间}五．执行结果：六．实验总结：通过这次操作系统中进程调度算法的模拟，使我对操作系统中的进程调度有了更清晰的认识和了解，程序中也有不足之处，该程序是顺序进链，出链时再选择优先数最大的进程。

操作系统实验一进程调度模拟算法

操作系统实验一进程调度模拟算法进程调度是操作系统中的一个重要功能，它负责为计算机系统中的各个进程分配CPU时间，使得所有进程都能够得到公平的执行机会。

进程调度算法的选择对于系统的性能和响应时间有着重要影响。

本文将介绍几种常见的进程调度算法，并进行模拟实验，分析它们的优缺点。

FCFS算法是最简单的调度算法之一，在该算法中，按照进程到达的先后顺序分配CPU时间。

FCFS算法的优点是简单易懂，公平性高，但其缺点是无法有效处理短作业和长作业混合的情况。

长作业会导致其他短作业等待时间过长，从而影响系统的响应时间。

2. 最短作业优先调度算法（Shortest Job First，SJF）SJF算法是一种非抢占式的调度算法，它会根据每个进程的执行时间来选择下一个执行的进程。

该算法的优点是可以最小化平均等待时间，但其缺点是无法预测进程的执行时间，如果估计不准确，会导致长作业等待时间过长。

3. 最高响应比优先调度算法（Highest Response Ratio Next，HRRN）HRRN算法是一种动态优先级调度算法，它根据每个进程的等待时间和服务时间的比值来选择最优的进程。

该算法考虑了进程的等待时间和服务时间的关系，能够相对公平地分配CPU时间，并且能够避免长作业的垄断。

4. 时间片轮转调度算法（Round Robin，RR）RR算法是一种抢占式的调度算法，它将所有进程按照到达顺序分配一个时间片，每个进程得到执行的时间是固定的。

当一个进程的时间片用完后，它会被放到就绪队列的末尾，等待下一次调度。

RR算法的优点是实现简单，能够保证所有进程能够得到公平的执行机会，但其缺点是当进程数量较大时，调度开销会增加。

在进程调度的模拟实验中，首先需要定义进程的数据结构，包括进程ID、到达时间、优先级、执行时间等属性。

然后，模拟进程的到达过程，可以使用随机数生成器模拟进程的到达时间和执行时间。

接下来，根据选择的调度算法，模拟进程的执行过程。

操作系统五种进程调度算法的代码

进程调度算法的模拟实现⏹实验目的1．本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

2．利用程序设计语言编写算法，模拟实现先到先服务算法FCFS、轮转调度算法RR、最短作业优先算法SJF、优先级调度算法PRIOR、最短剩余时间优先算法SRTF。

3．进行算法评价，计算平均等待时间和平均周转时间。

⏹实验内容及结果1．先来先服务算法2．轮转调度算法3. 优先级调度算法4. 最短时间优先算法5. 最短剩余时间优先算法⏹实验总结在此次模拟过程中，将SRTF单独拿了出来用指针表示，而其余均用数组表示。

⏹完整代码【Srtf.cpp代码如下：】//最短剩余时间优先算法的实现#include<stdio.h>#include<stdlib.h>#include<time.h>typedefstruct{int remain_time;//进程剩余执行时间int arrive_time;//进程到达时间int Tp;//进入就绪队列的时间int Tc;//进入执行队列的时间int To;//进程执行结束的时间int number;//进程编号}Process_Block;//定义进程模块typedefstruct _Queue{Process_Block PB;struct _Queue *next;}_Block,*Process;//定义一个进程模块队列中结点typedefstruct{Process head;//队列头指针Process end;//队列尾指针}Process_Queue;//进程队列Process_Queue PQ;//定义一个全局队列变量int t;//全局时间Process Run_Now;//当前正在运行的进程，作为全局变量void InitQueue(Process_Queue PQ){PQ.head ->next = NULL;PQ.end ->next = PQ.head;}/*初始化队列*/int IsEmpty(Process_Queue PQ){if(PQ.end->next == PQ.head)return 1;//队列空的条件为头指针指向尾指针并且尾指针指向头指针elsereturn 0;}/*判定队列是否为空队列*/void EnQueue(Process_Queue PQ,Process P){Process temp =(Process)malloc(sizeof(_Block));temp = PQ.end;temp->next->next = P;PQ.end->next = P;}/*插入队列操作*/Process DeQueue(Process_Queue PQ){if(IsEmpty(PQ))return NULL;Process temp = PQ.head->next;PQ.head->next= temp ->next;if(PQ.end->next == temp)PQ.end->next = PQ.head;return temp;}/*出列操作*/Process ShortestProcess(Process_Queue PQ){if(IsEmpty(PQ))//如果队列为空，返回{if(!Run_Now)return NULL;elsereturn Run_Now;}Process temp,shortest,prev;int min_time;if(Run_Now)//如果当前有进程正在执行，{shortest = Run_Now;//那么最短进程初始化为当前正在执行的进程，min_time = Run_Now->PB.remain_time;}else//如果当前没有进程执行，{shortest = PQ.head->next;//则最短进程初始化为队列中第一个进程min_time = PQ.head->next->PB.remain_time;}temp = PQ.head;prev = temp;while(temp->next){if(temp->next->PB.remain_time <min_time)//如果当前进程的剩余时间比min_time短，{shortest = temp->next;//则保存当前进程，min_time = shortest->PB.remain_time;prev=temp;//及其前驱}temp=temp->next;}if(shortest == PQ.end->next)//如果最短剩余时间进程是队列中最后一个进程，PQ.end->next = prev;//则需要修改尾指针指向其前驱prev->next = shortest->next;//修改指针将最短剩余时间进程插入到队头return shortest;}/*调度最短剩余时间的进程至队头*/void Run(){Run_Now->PB.remain_time--;//某一时间运行它的剩余时间减return;}/*运行函数*/void Wait(){return ;}int sum(intarray[],int n){int i,sum=0;for(i=0;i<n;i++)sum+=array[i];return sum;}int main(){PQ.head = (Process)malloc(sizeof(_Block));PQ.end = (Process)malloc(sizeof(_Block));Run_Now = (Process)malloc(sizeof(_Block));Run_Now =NULL;InitQueue(PQ);int i,N,Total_Time=0;//Total_Time为所有进程的执行时间之和printf("请输入计算机中的进程数目:\n");scanf("%d",&N);Process *P,temp;P = (Process*)malloc(N*sizeof(Process));int *wt,*circle_t;wt =(int*)malloc(N*sizeof(int));circle_t =(int*)malloc(N*sizeof(int));for(i=0;i<N;i++){P[i] = (Process)malloc(sizeof(_Block));P[i]->PB.number =i+1;P[i]->next =NULL;wt[i] =0;circle_t[i] =0;printf("输入第%d个进程的到达时间及剩余执行时间:\n",i+1);scanf("%d %d",&P[i]->PB.arrive_time,&P[i]->PB.remain_time);}for(i=0;i<N;i++)Total_Time+=P[i]->PB.remain_time;printf("\n进程按顺序运行依次为:\n");i=0;int k=0;for(t=0;;t++){if(Run_Now)//如果当前有进程正在执行{Run();if(t == P[i]->PB.arrive_time)//如果当前时间正好有进程进入{if(P[i]->PB.remain_time < Run_Now->PB.remain_time){temp = P[i];P[i] = Run_Now;Run_Now = temp;//则调度它至运行队列中，Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}EnQueue(PQ,P[i]);//并将当前运行进程重新插入队列中P[i]->PB.Tp=t;k++;i=(i+1)>(N-1)?(N-1):(i+1);}if(Run_Now->PB.remain_time == 0)//如果当前进程运行结束，{Run_Now->PB.To=t;//进程运行结束的时间circle_t[Run_Now->PB.number-1] +=t-Run_Now->PB.arrive_time;free(Run_Now);//则将它所占资源释放掉，Run_Now =NULL;//并修改Run_Now为NULLRun_Now = ShortestProcess(PQ);//从就绪队列中调出最短剩余时间进程至队头，if(!Run_Now)//如果队列为空，转为等待状态{if(IsEmpty(PQ) && k >= N) break;Wait();continue;}else{Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}}}else//如果当前运行进程为空，那么{if(t == P[i]->PB.arrive_time)//如果正好这时有进程入队{k++;EnQueue(PQ,P[i]);Run_Now = DeQueue(PQ);//则直接被调入运行队列中Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;printf("%d ",Run_Now->PB.number);i=(i+1)>(N-1)?(N-1):(i+1);}else{Wait();continue;}}}printf("\n");printf("平均等待时间是:\n%f\n",((float)sum(wt,N))/N);printf("平均周转时间是:\n%f\n",((float)sum(circle_t,N))/N);return 0;}//////////////////////////////////////////////////////【Process.cpp代码如下：】#include<iostream>#include<string>usingnamespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法void main(){int a;cout<<endl;cout<<" 选择调度算法："<<endl;cout<<" 1: FCFS 2: 时间片轮换3: 优先级调度4: 最短作业优先5: 最短剩余时间优先"<<endl; cin>>a;constint Size =30;Process process[Size] ;int num;int TimePice;cout<<" 输入进程个数:"<<endl;cin>>num;cout<<" 输入此进程时间片大小: "<<endl;cin>>TimePice;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<" 输入第"<< i+1<<" 个进程的名字、cpu时间和优先级:"<<endl;cin>>name;cin>> CpuTime>>Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" ( 说明: 在本程序所列进程信息中，优先级一项是指进程运行后的优先级!! )";cout<<endl; cout<<endl;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl; if(a==1)Fcfs(process,num,TimePice);elseif(a==2)TimeTurn( process, num, TimePice);elseif(a==3){Sort( process, num);Priority( process , num, TimePice);}else// 最短作业算法，先按时间从小到大排序，再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;} // 直接插入排序后进程按优先级从小到大排列for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;} // 此排序后按优先级从大到小排列}/*最短作业优先算法的实现*/void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}/*先来先服务算法的实现*/void Fcfs( Process process[], int num, int Timepice){ // process[] 是输入的进程，num是进程的数目，Timepice是时间片大小while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}elseif(process[num-1].LeftTime==0){cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!"<<endl;num--;}else{cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<"";cout<<process[s].LeftTime <<" "<<process[s].leval<<" 等待"<<endl; ;}} // elsecout<<endl;system(" pause");cout<<endl;} // while}/*时间片轮转调度算法实现*/void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}elseif(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<"";cout<<process[s].LeftTime <<" "<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;} // elsecout<<endl;system(" pause");cout<<endl;} // while}/*优先级调度算法的实现*/void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! "<<endl;for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl; // 输出其他进程for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval ; if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}。

操作系统进程调度模拟算法附源码

常见进程调度算法
先来先服务（FCFS）
定义：按照进程到达的先后顺序进行调度
优点：实现简单，适用于CPU繁忙型进程
缺点：等待时间较长，可能导致饥饿现象
适用场景：适用于 CPU密集型进程，不适用于I/O密集型进程
最短作业优先（SJF）
定义：按照作业的估计运行时间进行排序，选择最短作业优先执行优点：响应时间快，作业平均等待时间少缺点：存在饥饿现象，长作业可能长时间得不到执行适用场景：适用于作业量较大且作业到达时间间隔较长的情况
Part Five
模拟实验结果及分析
实验环境及参数设置
处理器：Intel Core i78700K
操作系统：Linux
内存：16GB DDR4 硬盘：256GB SSD
实验结果展示
实验数据：模拟算法在不同情况下的运行结果数据分析：对实验数据进行分析，得出结论结果对比：将模拟算法与实际操作系统进行对比，分析差异结果展示：以图表、表格等形式展示实验结果
优先级调度算法
定义：根据进程的优先级进行调度，优先级高的进程优先获得处理器
资源
分类：静态优先级调度算法和动态优先级
调度算法
静态优先级调度算法：优先级在进程创建时就确定，且在运行过程中
保持不变
动态优先级调度算法：优先级根据进程的行为和需求动
态调整
轮转法（RR）
定义：轮转法是一种简单且常用的进程调度算法，也称为循环调度
算法。
原理：按照进程到达的先后顺序，按照固定的时间片进行循环调度。
特点：每个进程分配一个固定时间片，时间片用完后自动切换到下一个进程，如果时间片未用完，则一直运行直到

操作系统五种进程调度算法的代码

优点：可以处理不同优先级的进程，提高系统的吞吐量
缺点：需要维护多个队列，增加了系统开销
汇报人：XX
适用场景：适用于多任务、多用户、分时的操作系统，以及对实时性要求较高的系统。
注意事项：在实现优先级调度算法时，需要注意避免优先级反转、优先级过高或过低等问题，以及合理地处理进程的优先级调整和动态变化。
轮转法调度算法是一种最简单的调度算法，它将作业按照到达时间的先后顺序进行排序，然后依次进行调度。
短作业优先（SJF）是一种非抢占式的进程调度算法，根据作业的长度进行调度。
SJF算法将作业按照其所需执行时间从短到长进行排序。
如果一个进程比其他进程短，即使它已经等待了很长时间，它仍然会被优先调度。
短作业优先调度算法（SJF）的代码实现需要考虑作业的到达时间和执行时间，根据优先级进行调度。
在代码中，需要定义作业队列和作业列表，以便对作业进行排序和调度。
实现任务调度函数
实时系统或关键任务调度系统
任务数量较少且优先级可调整的系统
任务优先级明确且相对固定的系统
需要快速响应和高吞吐量的系统
添加标题
添加标题
添加标题
添加标题
缺点：实现较为复杂，需要合理地确定进程的优先级和调度策略，否则可能导致系统性能下降或者某些进程得不到及时处理。
优点：能够根据进程的紧迫程度和优先级进行调度，优先处理紧急和重要的任务，提高了系统的响应速度和吞吐量。
轮转法调度算法的代码实现通常包括一个循环和一个等待队列，循环用于不断从等待队列中取出进程执行，等待队列用于存储待执行的进程。
在代码实现中，需要考虑到进程的到达时间、运行时间、等待时间和周转时间等参数，以便正确地调度进程。
轮转法调度算法的代码实现需要考虑进程的优先级和紧急程度等因素，以便更好地满足系统的需求。

进程调度实验报告源码

一、实验目的本次实验旨在通过模拟进程调度过程，加深对进程调度算法的理解，并掌握进程调度程序的设计与实现方法。

实验内容主要包括：创建进程、进程调度、进程执行、进程结束等。

二、实验环境操作系统：Linux编程语言：C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法：FIFO（先进先出）、时间片轮转法、多级反馈队列调度算法。

2. 进程调度程序设计进程调度程序主要由以下部分组成：（1）进程控制块（PCB）PCB用于描述进程的基本信息，包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。

（2）就绪队列就绪队列用于存储处于就绪状态的进程，按照进程的优先级或到达时间进行排序。

（3）进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行，并将CPU分配给该进程。

（4）进程执行函数进程执行函数负责模拟进程的执行过程，包括进程的创建、执行、结束等。

四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明，FIFO调度算法按照进程的到达时间进行调度，可能导致短作业等待时间长，效率较低。

操作系统-进程调度模拟算法(附源码)

进程调度模拟算法课程名称：计算机操作系统班级：信1501-2实验者姓名：李琛实验日期：2018年5月1日评分：教师签名：一、实验目的进程调度是处理机管理的核心内容。

本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。

二、实验要求1.设计进程控制块PCB 的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU 时间、进程到完成还需要的时间、进程的状态、当前队列指针等。

2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。

三、实验过程分别用两种调度算法对伍个进程进行调度。

每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。

（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数 2）CPUTIME——进程累计占用 CPU 的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。

（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减 1，CPU 时间片数加 1，进程还需要的时间片数减 1。

在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加 2，进程还需要的时间片数减 2，并退出 CPU，排到就绪队列尾，等待下一次调度。

进程调度模拟实验--源代码

#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct node /*创建PCB*/{ char name[10]; /*进程标识*/int prio; /*进程优先数*/int cputime; /*进程占用CPU时间*/int needtime; /*进程完成所需时间*/int count; /*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run;int N;//************************************************************************* void firstin() /*创建就绪队列对头指针*/{run=ready;run->state='R';ready=ready->next;}//************************************************************************* void prt(char algo) /*演示进程调度*/{PCB *p;printf(" 标识占用CPU时间完成所需时间优先数状态\n");if(run!=NULL)printf(" %-6s%-14d%-14d%-8d %c\n",run->name,run->cputime,run->needtime,run->prio,run->state);p=ready;while(p!=NULL){ printf(" %-6s%-14d%-14d%-8d %c\n",p->name,p->cputime,p->needtime,p->prio,p->state);p=p->next;}p=finish;while(p!=NULL){ printf(" %-6s%-14d%-14d%-8d %c\n",p->name,p->cputime,p->needtime,p->prio,p->state);p=p->next;}getchar();}//*************************************************************************void insert(PCB *q){PCB *p1,*s,*r;int b;s=q;p1=ready;r=p1;b=1;while((p1!=NULL)&&b)if(p1->prio>=s->prio){r=p1;p1=p1->next;}elseb=0;if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1;ready=s;}}//************************************************************************* void create(char alg) /*创建各个进程*/{PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;for(i=1;i<=N;i++){p=(PCB *)malloc(sizeof(PCB));printf("输入进程的标识:\n");scanf("%s",na);printf("输入进程的时间(不要超过50):\n");scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='w';p->prio=50-time; /*假设优先级与耗时之和为50*/if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}}// clrscr();printf(" 显示进程\n");printf("************************************************\n");prt(alg);run=ready;ready=ready->next;run->state='R';}//************************************************************************* void priority(char alg) /*优先级算法调度*/{while(run!=NULL&&run->prio>=0){run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3;if(run->needtime==0){run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin();}elseif((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert(run);firstin();}prt(alg);}}//************************************************************************* void main(){ char algo;// clrscr();loop: printf("输入进程的总数(不要超过10个):\n");scanf("%d",&N);if(N>10){printf("输入的数字太大，请重新输入.\n");goto loop;}create(algo);priority(algo);}。

操作系统进程调度模拟算法附源码

进程调度算法模拟以及代码实现原创

操作系统进程调度算法模拟__MFC实现

进程调度算法实现代码(操作系统)

操作系统进程调度仿真程序源码

进程调度算法代码

操作系统进程调度C语言代码

2实验二进程调度(优先数调度)参考代码

操作系统五种进程调度算法的代码

实验一 进程调度模拟算法

操作系统课程设计进程调度模拟源代码

操作系统进程调度算法模拟

操作系统实验一进程调度模拟算法

操作系统五种进程调度算法的代码

操作系统进程调度模拟算法附源码

操作系统五种进程调度算法的代码

进程调度实验报告源码

操作系统-进程调度模拟算法(附源码)

进程调度模拟实验--源代码

实验一进程调度模拟算法