使用c语言编写时间片论证调度算法当前时间为0点,时间单位为分钟。程序通过命令行

时间片调度算法是一种常用的调度算法，其主要思想是将CPU的执行时间划分为固定大小的时间片，每个进程在一个时间片内运行，然后切换到下一个进程。这样可以实现多个进程的并发执行。

使用C语言编写时间片调度算法，可以通过命令行输入进程的相关信息，包括进程ID、到达时间和运行时间。然后按照到达时间的先后顺序进行排序，通过循环遍历进程列表来进行调度。

在当前时间为0点的情况下，首先需要输入进程的数量，并根据数量动态分配内存空间来存储进程信息。然后通过循环输入每个进程的ID、到达时间和运行时间，并初始化进程的状态为就绪。

在进程到达时间到达后，根据时间片大小来执行每个进程。如果在一个时间片内进程的运行时间未完成，则将其状态设置为就绪，等待下一个时间片。如果进程运行时间已经完成，则将其状态设置为结束。

当所有进程都结束后，计算每个进程的周转时间和带权周转时间，并输出结果。

在编写代码时，可以使用结构体来表示进程的信息，如进程ID、到达时间、运行时间和状态。使用数组来存储多个进程的信息。通过循环和条件判断来实现调度算法的具体逻辑。

综上所述，以上是使用C语言编写时间片调度算法的一个简单思路和实现方式，通过命令行输入进程信息，按照到达时间进行排序并进行调度执行，最后计算和输出结果。

相关问题

用虚拟机c语言编写时间片轮转调度算法

好的，下面是一份简单的时间片轮转调度算法的 C 语言实现代码。在这个示例中，我们使用了一个结构体来代表进程，并且每个进程都有一个唯一的 ID 和一个剩余的执行时间量（用于模拟进程的执行）。

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

#define TIME_QUANTUM 2  // 时间片长度

// 进程的结构体定义
typedef struct process {
    int id;  // 进程 ID
    int exec_time;  // 剩余执行时间
} process_t;

int main() {
    int num_processes;  // 进程数
    printf("请输入进程数：");
    scanf("%d", &num_processes);

    // 动态分配存储空间
    process_t *processes = (process_t *)malloc(num_processes * sizeof(process_t));

    // 初始化进程
    for (int i = 0; i < num_processes; i++) {
        processes[i].id = i;
        printf("请输入进程 %d 的执行时间：", i);
        scanf("%d", &processes[i].exec_time);
    }

    // 时间片轮转调度算法
    int time = 0;  // 当前时间
    int curr_proc = 0;  // 当前执行的进程
    while (1) {
        // 执行当前进程
        processes[curr_proc].exec_time -= TIME_QUANTUM;
        time += TIME_QUANTUM;

        // 判断当前进程是否执行完毕
        if (processes[curr_proc].exec_time <= 0) {
            printf("进程 %d 执行完毕，用时 %d 秒\n", curr_proc, time);
            num_processes--;

            // 如果所有进程都执行完毕，则退出循环
            if (num_processes == 0) {
                break;
            }

            // 删除当前进程，并选择下一个进程
            for (int i = curr_proc; i < num_processes; i++) {
                processes[i] = processes[i + 1];
            }
            curr_proc = curr_proc % num_processes;
        }

        // 选择下一个进程
        curr_proc = (curr_proc + 1) % num_processes;
    }

    // 释放存储空间
    free(processes);

    return 0;
}

这个示例程序可以通过用户输入进程数和每个进程的执行时间来模拟时间片轮转调度算法的执行过程，并输出每个进程的执行时间。需要注意的是，在实际的操作系统中，可能会使用更加复杂的调度算法来确保系统的性能和响应速度。

用C语言写时间片轮转调度算法和多级反馈队列调度算法

时间片轮转调度算法的C语言实现：

#include <stdio.h>

// 进程控制块结构体
typedef struct PCB{
    int pid;    // 进程ID
    int burst;  // 进程执行时间
    int wait;   // 进程等待时间
    int tat;    // 进程周转时间
    int rt;     // 进程剩余时间
} PCB;

// 时间片轮转调度算法
void RR(PCB *p, int n, int q) {
    int t = 0;  // 记录当前时间
    int done = 0; // 记录已经完成的进程数
    while(done < n) {
        int flag = 0;   // 标记是否有进程在执行
        for(int i = 0; i < n; i++) {
            if(p[i].rt > 0) {   // 判断进程是否还有剩余时间
                flag = 1;   // 标记有进程在执行
                if(p[i].rt > q) {   // 进程还需执行时间大于时间片
                    t += q; // 更新当前时间
                    p[i].rt -= q;   // 更新进程剩余时间
                } else {
                    t += p[i].rt;   // 更新当前时间
                    p[i].wait = t - p[i].burst; // 计算进程等待时间
                    p[i].tat = t;   // 计算进程周转时间
                    p[i].rt = 0;    // 进程已经执行完
                    done++; // 已经完成的进程数+1
                }
            }
        }
        if(flag == 0) break; // 所有进程都已经执行完
    }
    printf("进程ID\t等待时间\t周转时间\n");
    for(int i = 0; i < n; i++) {
        printf("%d\t%d\t%d\n", p[i].pid, p[i].wait, p[i].tat);
    }
}

int main() {
    // 初始化进程控制块
    PCB p[] = {
        {1, 24, 0, 0, 24},
        {2, 3, 0, 0, 3},
        {3, 3, 0, 0, 3}
    };
    int n = sizeof(p) / sizeof(PCB);
    int q = 4;  // 时间片大小
    RR(p, n, q);
    return 0;
}

多级反馈队列调度算法的C语言实现：

#include <stdio.h>

// 进程控制块结构体
typedef struct PCB{
    int pid;    // 进程ID
    int burst;  // 进程执行时间
    int wait;   // 进程等待时间
    int tat;    // 进程周转时间
    int rt;     // 进程剩余时间
    int prio;   // 进程优先级
} PCB;

// 多级反馈队列调度算法
void MFQ(PCB *p, int n, int q1, int q2) {
    int t = 0;  // 记录当前时间
    int done = 0; // 记录已经完成的进程数
    while(done < n) {
        int flag = 0;   // 标记是否有进程在执行
        // 第一级队列，时间片大小为q1
        for(int i = 0; i < n; i++) {
            if(p[i].prio == 1 && p[i].rt > 0) {    // 判断进程是否在第一级队列中
                flag = 1;   // 标记有进程在执行
                if(p[i].rt > q1) {  // 进程还需执行时间大于时间片
                    t += q1; // 更新当前时间
                    p[i].rt -= q1;  // 更新进程剩余时间
                } else {
                    t += p[i].rt;   // 更新当前时间
                    p[i].wait = t - p[i].burst; // 计算进程等待时间
                    p[i].tat = t;   // 计算进程周转时间
                    p[i].rt = 0;    // 进程已经执行完
                    p[i].prio = 2;  // 进程优先级变为第二级
                    done++; // 已经完成的进程数+1
                }
            }
        }
        // 第二级队列，时间片大小为q2
        for(int i = 0; i < n; i++) {
            if(p[i].prio == 2 && p[i].rt > 0) {    // 判断进程是否在第二级队列中
                flag = 1;   // 标记有进程在执行
                if(p[i].rt > q2) {  // 进程还需执行时间大于时间片
                    t += q2; // 更新当前时间
                    p[i].rt -= q2;  // 更新进程剩余时间
                } else {
                    t += p[i].rt;   // 更新当前时间
                    p[i].wait = t - p[i].burst; // 计算进程等待时间
                    p[i].tat = t;   // 计算进程周转时间
                    p[i].rt = 0;    // 进程已经执行完
                    done++; // 已经完成的进程数+1
                }
            }
        }
        if(flag == 0) break; // 所有进程都已经执行完
    }
    printf("进程ID\t等待时间\t周转时间\n");
    for(int i = 0; i < n; i++) {
        printf("%d\t%d\t%d\n", p[i].pid, p[i].wait, p[i].tat);
    }
}

int main() {
    // 初始化进程控制块
    PCB p[] = {
        {1, 10, 0, 0, 10, 1},
        {2, 1, 0, 0, 1, 1},
        {3, 2, 0, 0, 2, 1},
        {4, 1, 0, 0, 1, 1},
        {5, 5, 0, 0, 5, 1},
    };
    int n = sizeof(p) / sizeof(PCB);
    int q1 = 2; // 第一级队列时间片大小
    int q2 = 4; // 第二级队列时间片大小
    MFQ(p, n, q1, q2);
    return 0;
}