CS162 11-12 调度与死锁

**调度与死锁**

在计算机系统中，调度是指决定哪个进程或线程应该运行的过程。调度算法可以分为两大类：时间片轮转调度（Time-Slicing Scheduling）和优先级调度（Priority Scheduling）。

### 时间片轮转调度时间片轮转调度是一种简单的调度算法，主要用于单处理器系统中。该算法将每个进程分配一个固定大小的时间片（Time Quantum），当一个进程使用完了自己的时间片后，它会被暂停并让其他进程运行。

**代码示例**

c#include <stdio.h>
#include <stdlib.h>

// 进程结构体typedef struct Process {
 int pid;
 int arrival_time; // 到达时间 int burst_time; // 执行时间} Process;

// 时间片轮转调度函数void time_slice_scheduling(Process processes[], int num_processes, int time_quantum) {
 for (int i =0; i < num_processes; i++) {
 printf("进程 %d 到达时间:%d 执行时间:%d
", processes[i].pid, processes[i].arrival_time, processes[i].burst_time);
 // 如果当前进程到达时间早于上一个进程完成时间，则执行当前进程 if (i ==0 || processes[i].arrival_time >= processes[i -1].completion_time) {
 printf("进程 %d 开始执行...
", processes[i].pid);
 // 执行当前进程 for (int j =0; j < processes[i].burst_time / time_quantum +1; j++) {
 printf("进程 %d 正在执行...
", processes[i].pid);
 // 模拟执行时间片 sleep(time_quantum *1000); // 等待时间片结束 if (j == processes[i].burst_time / time_quantum) {
 printf("进程 %d 执行完成!
", processes[i].pid);
 // 记录当前进程完成时间 processes[i].completion_time = j * time_quantum + processes[i].arrival_time;
 }
 }
 } else {
 printf("进程 %d 等待...
", processes[i].pid);
 // 等待上一个进程完成 sleep(processes[i -1].completion_time - processes[i].arrival_time) *1000;
 }
 }
}

int main() {
 Process processes[] = {{1,0,5}, {2,3,4}, {3,6,7}};
 int num_processes = sizeof(processes) / sizeof(processes[0]);
 // 设置时间片大小 int time_quantum =2;
 time_slice_scheduling(processes, num_processes, time_quantum);
 return0;
}

c#include <stdio.h>
#include <stdlib.h>

// 进程结构体typedef struct Process {
 int pid;
 int arrival_time; // 到达时间 int burst_time; // 执行时间 int priority; //优先级} Process;

//优先级调度函数void priority_scheduling(Process processes[], int num_processes) {
 for (int i =0; i < num_processes; i++) {
 printf("进程 %d 到达时间:%d 执行时间:%d优先级:%d
", processes[i].pid, processes[i].arrival_time, processes[i].burst_time, processes[i].priority);
 // 根据优先级决定哪个进程应该运行 if (processes[i].priority > processes[i -1].priority) {
 printf("进程 %d 开始执行...
", processes[i].pid);
 // 执行当前进程 for (int j =0; j < processes[i].burst_time /2 +1; j++) {
 printf("进程 %d 正在执行...
", processes[i].pid);
 // 模拟执行时间片 sleep(1000); // 等待时间片结束 if (j == processes[i].burst_time /2) {
 printf("进程 %d 执行完成!
", processes[i].pid);
 // 记录当前进程完成时间 processes[i].completion_time = j *1000 + processes[i].arrival_time;
 }
 }
 } else {
 printf("进程 %d 等待...
", processes[i].pid);
 // 等待上一个进程完成 sleep(processes[i -1].completion_time - processes[i].arrival_time) *1000;
 }
 }
}

int main() {
 Process processes[] = {{1,0,5,3}, {2,3,4,2}, {3,6,7,1}};
 int num_processes = sizeof(processes) / sizeof(processes[0]);
 priority_scheduling(processes, num_processes);
 return0;
}

c#include <stdio.h>
#include <stdlib.h>

// 进程结构体typedef struct Process {
 int pid;
 int arrival_time; // 到达时间 int burst_time; // 执行时间} Process;

// 死锁函数void deadlock(Process processes[], int num_processes) {
 for (int i =0; i < num_processes; i++) {
 printf("进程 %d 到达时间:%d 执行时间:%d
", processes[i].pid, processes[i].arrival_time, processes[i].burst_time);
 // 如果当前进程到达时间早于上一个进程完成时间，则执行当前进程 if (i ==0 || processes[i].arrival_time >= processes[i -1].completion_time) {
 printf("进程 %d 开始执行...
", processes[i].pid);
 // 执行当前进程 for (int j =0; j < processes[i].burst_time /2 +1; j++) {
 printf("进程 %d 正在执行...
", processes[i].pid);
 // 模拟执行时间片 sleep(1000); // 等待时间片结束 if (j == processes[i].burst_time /2) {
 printf("进程 %d 执行完成!
", processes[i].pid);
 // 记录当前进程完成时间 processes[i].completion_time = j *1000 + processes[i].arrival_time;
 // 等待下一个进程执行完毕 sleep(processes[i +1].completion_time - processes[i].arrival_time) *1000;
 }
 }
 } else {
 printf("进程 %d 等待...
", processes[i].pid);
 // 等待上一个进程完成 sleep(processes[i -1].completion_time - processes[i].arrival_time) *1000;
 }
 }
}

int main() {
 Process processes[] = {{1,0,5}, {2,3,4}, {3,6,7}};
 int num_processes = sizeof(processes) / sizeof(processes[0]);
 deadlock(processes, num_processes);
 return0;
}