系统调度实现

0 : FCFS
新到达的进程被添加到队列的末尾。
当一个进程由于I/O而被阻塞，然后变得就绪时，它会被添加到队列的末尾。如果两个进程同时就绪,则优先选择ID较小的进程。
1 :RR与量子2。
如果发生以下情况之一，则安排流程:
当前正在运行的进程终止
当前正在运行的进程在I/O上被阻止当前运行进程运行了2个周期
您可以将RR视为就绪进程的队列。当进程从运行状态变为就绪状态时，它会移动到队列的末尾。如果两个进程同时变为Ready,则优先选择ID较小的进程
2:最短剩余作业优先(抢占式）
在每个周期，您计算所有就绪/正在运行的进程的剩余CPU时间，并运行剩余时间最短的进程。如果多个进程的剩余CPU时间相同,则优先选择ID较小的进程
 

 

#include <stdio.h>

#define MAX_SIZE 100

typedef struct Process {
    int processId;
    int arrivalTime;
    int executionTime;
    int remainingTime;
    int isBlocked;
} Process;

typedef struct Queue {
    Process processes[MAX_SIZE];
    int front;
    int rear;
    int size;
} Queue;

void initializeQueue(Queue* queue) {
    queue->front = 0;
    queue->rear = -1;
    queue->size = 0;
}

int isEmpty(Queue* queue) {
    return queue->size == 0;
}

int isFull(Queue* queue) {
    return queue->size == MAX_SIZE;
}

void enqueue(Queue* queue, Process process) {
    if (isFull(queue)) {
        printf("队列已满，无法入队\n");
        return;
    }

    queue->rear = (queue->rear + 1) % MAX_SIZE;
    queue->processes[queue->rear] = process;
    queue->size++;
}

Process dequeue(Queue* queue) {
    if (isEmpty(queue)) {
        printf("队列为空，无法出队\n");
        Process emptyProcess;
        emptyProcess.processId = -1;
        return emptyProcess;
    }

    Process process = queue->processes[queue->front];
    queue->front = (queue->front + 1) % MAX_SIZE;
    queue->size--;

    return process;
}

void sortProcessesByArrivalTime(Process processes[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (processes[j].arrivalTime > processes[j + 1].arrivalTime) {
                Process temp = processes[j];
                processes[j] = processes[j + 1];
                processes[j + 1] = temp;
            }
        }
    }
}
void fcfs(Process processes[], int n) {
    Queue readyQueue;
    initializeQueue(&readyQueue);

    // 将进程按照到达时间排序
    sortProcessesByArrivalTime(processes, n);

    int currentTime = 0;
    int totalExecutionTime = 0;

    // 执行进程调度
    while (1) {
        // 检查是否有新进程到达并加入就绪队列
        for (int i = 0; i < n; i++) {
            if (processes[i].arrivalTime == currentTime) {
                // 如果队列中已有进程，比较进程ID并将较小的进程放在队列前面
                if (!isEmpty(&readyQueue)) {
                    if (processes[i].processId < readyQueue.processes[readyQueue.front].processId) {
                        enqueue(&readyQueue, processes[i]);
                    } else {
                        Process temp = dequeue(&readyQueue);
                        enqueue(&readyQueue, processes[i]);
                        enqueue(&readyQueue, temp);
                    }
                } else {
                    enqueue(&readyQueue, processes[i]);
                }
            }
        }

        // 执行当前进程
        if (!isEmpty(&readyQueue)) {
            Process currentProcess = dequeue(&readyQueue);
            printf("当前时间: %d，执行进程: P%d\n", currentTime, currentProcess.processId);

            currentProcess.remainingTime--;
            totalExecutionTime++;

            // 判断进程是否执行完毕
            if (currentProcess.remainingTime == 0) {
                printf("进程 P%d 执行完毕\n", currentProcess.processId);
            } else {
                enqueue(&readyQueue, currentProcess);
            }
        }

        // 检查所有进程是否执行完毕
        if (totalExecutionTime == n) {
            break;
        }

        currentTime++;
    }
}


void rr(Process processes[], int n, int quantum) {
    Queue readyQueue;
    initializeQueue(&readyQueue);

    // 将进程按照到达时间排序
    sortProcessesByArrivalTime(processes, n);

    int currentTime = 0;
    int totalExecutionTime = 0;

    // 记录进程是否已经运行了2个周期
    int runningTime = 0;

    // 执行进程调度
    while (1) {
        // 检查是否有新进程到达并加入就绪队列
        for (int i = 0; i < n; i++) {
            if (processes[i].arrivalTime == currentTime) {
                enqueue(&readyQueue, processes[i]);
            }
        }

        // 执行当前进程
        if (!isEmpty(&readyQueue)) {
            Process currentProcess = dequeue(&readyQueue);
            printf("当前时间: %d，执行进程: P%d\n", currentTime, currentProcess.processId);

            // 判断进程是否执行完毕
            if (currentProcess.remainingTime <= quantum) {
                printf("进程 P%d 执行完毕\n", currentProcess.processId);
                totalExecutionTime++;
                currentTime += currentProcess.remainingTime;
                runningTime = 0;
            } else {
                currentProcess.remainingTime -= quantum;
                enqueue(&readyQueue, currentProcess);
                currentTime += quantum;
                runningTime += quantum;
            }

            // 判断是否运行了2个周期
            if (runningTime >= 2 * quantum) {
                printf("进程 P%d 被阻塞\n", currentProcess.processId);
                runningTime = 0;
            }
        }

        // 检查所有进程是否执行完毕
        if (totalExecutionTime == n) {
            break;
        }
    }
}

void sjf(Process processes[], int n) {
    Queue readyQueue;
    initializeQueue(&readyQueue);

    // 将进程按照到达时间排序
    sortProcessesByArrivalTime(processes, n);

    int currentTime = 0;
    int totalExecutionTime = 0;

    // 执行进程调度
    while (1) {
        // 检查是否有新进程到达并加入就绪队列
        for (int i = 0; i < n; i++) {
            if (processes[i].arrivalTime == currentTime) {
                enqueue(&readyQueue, processes[i]);
            }
        }

        // 执行当前进程
        if (!isEmpty(&readyQueue)) {
            Process shortestProcess = readyQueue.processes[readyQueue.front];
            int shortestIndex = readyQueue.front;

            // 查找剩余时间最短的进程
            for (int i = readyQueue.front + 1; i <= readyQueue.rear; i++) {
                if (readyQueue.processes[i].remainingTime < shortestProcess.remainingTime) {
                    shortestProcess = readyQueue.processes[i];
                    shortestIndex = i;
                } else if (readyQueue.processes[i].remainingTime == shortestProcess.remainingTime) {
                    if (readyQueue.processes[i].processId < shortestProcess.processId) {
                        shortestProcess = readyQueue.processes[i];
                        shortestIndex = i;
                    }
                }
            }

            // 移除就绪队列中的最短进程
            for (int i = shortestIndex; i < readyQueue.rear; i++) {
                readyQueue.processes[i] = readyQueue.processes[i + 1];
            }
            readyQueue.rear--;
            readyQueue.size--;

            printf("当前时间: %d，执行进程: P%d\n", currentTime, shortestProcess.processId);

            shortestProcess.remainingTime--;
            totalExecutionTime++;

            // 判断进程是否执行完毕
            if (shortestProcess.remainingTime == 0) {
                printf("进程 P%d 执行完毕\n", shortestProcess.processId);
            } else {
                enqueue(&readyQueue, shortestProcess);
            }
        }

        // 检查所有进程是否执行完毕
        if (totalExecutionTime == n) {
            break;
        }

        currentTime++;
    }
}


int main() {
    Process processes[5];

    // 设置进程的到达时间、执行时间和剩余执行时间
    processes[0].processId = 1;
    processes[0].arrivalTime = 0;
    processes[0].executionTime = 4;
    processes[0].remainingTime = 4;

    processes[1].processId = 2;
    processes[1].arrivalTime = 1;
    processes[1].executionTime = 3;
    processes[1].remainingTime = 3;

    processes[2].processId = 3;
    processes[2].arrivalTime = 2;
    processes[2].executionTime = 2;
    processes[2].remainingTime = 2;

    processes[3].processId = 4;
    processes[3].arrivalTime = 3;
    processes[3].executionTime = 1;
    processes[3].remainingTime = 1;

    processes[4].processId = 5;
    processes[4].arrivalTime = 4;
    processes[4].executionTime = 5;
    processes[4].remainingTime = 5;

    printf("FCFS调度算法\n");
    fcfs(processes, 5);

    printf("\n");

    printf("RR调度算法\n");
    rr(processes, 5, 2);

    printf("\n");

    printf("SJF调度算法\n");
    sjf(processes, 5);

    return 0;
}