调度策略的实现

调度策略

1. 先来先服务
2. 短作业优先
3. 高响应比
4. 时间片
5. 三级反馈调度

实现准备：

1）order数组代表进程开始时间顺序。

//模拟进程到来顺序
    for (int i = 0; i < num; i++) {
        for (int j = i + 1; j < num; j++) {
            if (pcbdata[order[i]].time_start > pcbdata[order[j]].time_start) {
                int s = order[i];
                order[i] = order[j];
                order[j] = s;
            }
        }
    }

2）进程数组

typedef struct pcb PCB;
struct pcb {
    int id;
    char name[10];
    int time_start;
    int time_need;
    int time_left;
    int time_used;
    int time_exit;
    char state;
};

int num = 5;
PCB pcbdata[10] = {
        {1000, "A", 0, 4, 4, 0, 0, 'R'},
        {1001, "B", 1, 3, 3, 0, 0, 'R'},
        {1002, "C", 2, 5, 5, 0, 0, 'R'},
        {1003, "D", 3, 2, 2, 0, 0, 'R'},
        {1004, "E", 4, 4, 4, 0, 0, 'R'}
};

3）按需执行的执行方法

int exec(int i, PCB *pcb, int current_time) {
    printf("\n第%d个进程--%s", i + 1, pcb->name);
    printf("到达时间--%d，服务时间--%d，\n", pcb->time_start, pcb->time_need);
    printf("第%d个进程正在运行......\n", i + 1);

    current_time += pcb->time_need;
    pcb->time_exit = current_time;

    printf("运行结束\n");
    int turnover_time = current_time - pcb->time_start;
    float turnover_right = (float) turnover_time / pcb->time_need;
    printf("完成时间--%d，周转时间--%d，带权周转时间--%.1f\n", current_time, turnover_time, turnover_right);

    return current_time;
}

4）非抢占式按单位时间执行的执行方法

void exec_Slice(PCB *pcb, int current_time) {

    printf("第%d秒%s运行\n", current_time, pcb->name);

    pcb->time_left--;
    pcb->time_used++;

    if (pcb->time_left == 0) {
        pcb->time_exit = current_time + 1;
     	pcb->state = 'E';
    }

}

5）抢占式按单位时间执行的执行方法

int MRLA_exec(MRLA_Node *node, int current_time, int *isExec) {
    if (node == NULL || node->time_slice == 0 || *isExec == 1) {
        return 0;
    }
    node->time_slice--;
    exec_Slice(&pcbdata[node->handle], current_time);
    *isExec = 1;
    return 1;
}

6）打印方法

void my_printf() {
    printf("%s\t%s\t%s\t%s\t%s\t%s\t\n", "name", "time_start", "time_need", "time_exit","time_turnover","turnover_right");
    for (int i = 0; i < num; ++i) {
        printf("%s\t%d\t\t%d\t\t%d\t\t%d\t\t%lf\t\n", pcbdata[i].name, pcbdata[i].time_start, pcbdata[i].time_need,
               pcbdata[i].time_exit, pcbdata[i].time_exit - pcbdata[i].time_start,
               (float) (pcbdata[i].time_exit - pcbdata[i].time_start) / pcbdata[i].time_need);
    }
    printf("-----所有进程调度完毕---------\n");
}

7）ready为先来先服务，短作业优先，时间片的就绪队列

8）三级调度队列的将数据结构及方法声明

typedef struct MRLA_Node {
    int handle; //进程句柄
    int time_slice; //该进程时间片执行时间剩余量
    struct MRLA_Node *next;
} MRLA_Node;

typedef struct MRLA_Queue {
    struct MRLA_Node *front, *rear;
} MRLA_Queue;

//-----------------多级反馈队列操作----------------------
//初始化链式队列
void init_queue(MRLA_Queue *queue);

//链式队列的入队操作
void MRLA_push(MRLA_Queue *queue, MRLA_Node *p);

//链式队列的出队操作
MRLA_Node *MRLA_pop(MRLA_Queue *queue);

//判空操作
int isEmpty(MRLA_Queue queue);

//释放队列
void close(MRLA_Queue queue);

//可抢占式按秒执行
int MRLA_exec(MRLA_Node *node, int current_time, int *isExec);

//-----------------------------------------------

1. 先来先服务实现：
   ready就绪队列按order顺序队列，直接按就绪队列顺序执行。

    int current_time = pcbdata[order[0]].time_start;
    int flag = 0; //标识在当前时间是否存在已到达进程

    for (int i = 0; i < num;) {

        //执行状态为'R'的已到达的服务时间最短的一个进程
        for (int j = 0; j < num; j++) {
            if (pcbdata[ready[j]].time_start <= current_time && pcbdata[ready[j]].state== 'R') {
                flag = 1;
                current_time = exec(i, &pcbdata[ready[j]], current_time);
        
        		pcbdata[ready[j]].state = 'E';
                i++;
                break;
            }
        }
        //无进程在此刻，时间按秒自加
        if (flag == 0) {
            current_time++;
        }
        flag = 0;
    }
    my_printf();

2. 短作业优先实现：
   每次执行完一个当前进程后，对通过遍历找到最短已到达的进程，将其排在队首。并执行，再将其进程状态改为已执行。

    int current_time = pcbdata[order[0]].time_start;
    int flag = 0; //标识在当前时间是否存在已到达进程

    for (int i = 0; i < num;) {

        //执行状态为'R'的已到达的服务时间最短的一个进程
        for (int j = 0; j < num; j++) {
            if (pcbdata[ready[j]].time_start <= current_time && pcbdata[ready[j]].state== 'R') {
                flag = 1;
                current_time = exec(i, &pcbdata[ready[j]], current_time);
        
        		pcbdata[ready[j]].state = 'E';
                i++;
                break;
            }
        }
        //无进程在此刻，时间按秒自加
        if (flag == 0) {
            current_time++;
        }
        flag = 0;
    }
    my_printf();

3. 高优先比实现：
   每次执行完，寻找此刻已到达且未执行的进程优先比最大的进程，并将其排在队首。

    int current_time = pcbdata[order[0]].time_start;

    for (int i = 0; i < num;) {

        //寻找在此刻响应比最高且已到达的未执行进程，并将其作为就绪数组之首
        for (int j = 0; j < num; j++) {
            if (get_responseRatio(current_time, pcbdata[ready[0]]) <
                get_responseRatio(current_time, pcbdata[ready[j]]) &&
                current_time >= pcbdata[ready[j]].time_start) {
                int temp = ready[j];
                ready[j] = ready[0];
                ready[0] = temp;
            }
        }

        //如果存在，执行进程，否则时间执行自加
        if (pcbdata[ready[0]].state == 'R') {
            current_time = exec(i, &pcbdata[ready[0]], current_time);
            pcbdata[ready[0]].state = 'E';
            i++;
        } else {
            current_time++;
        }
    }

    my_printf();

4. 时间片实现：
   将ready数组看做循环队列。
   设置循环队列的头尾指针

int front = 0, rear = 0;//循环队列头,尾指针

设置pop和push方法

//----------------时间片的就绪队列操作---------------
//循环队列的出队操作
int RR_pop(int queue[], int *front, const int *rear);

//循环队列的入队操作
int RR_push(int queue[], const int *front, int *rear, int handle);
//-----------------------------------------------

while循环设置为按秒循环，并使用非抢占式按单位时间执行的执行方法，通过取余实现时间片执行。

    int front = 0, rear = 0;//循环队列头,尾指针

    printf("---------------时间片-------------------\n");
    int current_time = pcbdata[order[0]].time_start;
    int time = current_time; //用于将当前时间片执行时间归零

    int count = 0;//已进入就绪队列的个数

    while (front != rear || count != num) {

        if (count != num) {
            for (int i = count; i < num; ++i) {
                if (current_time == pcbdata[order[count]].time_start) {
                    RR_push(ready, &front, &rear, order[count]);
                    count++;
                }

            }
        }

        //判空
        if (front != rear) {
            exec_Slice(&pcbdata[ready[front]], current_time);
        }
        current_time++;

        //按时间片和执行时间片结束的进程的状态，执行出队操作，并由进程状态决定是否执行入队操作
        if ((current_time - time) % slice_size == 0 || pcbdata[ready[front]].state == 'E') {
            int x = RR_pop(ready, &front, &rear);
            if (pcbdata[x].state != 'E') {
                RR_push(ready, &front, &rear, x);
            } else {
                time = pcbdata[x].time_exit;
            }
        }
    }
    my_printf();

5. 三级反馈调度实现：
   数据结构使用三级队列的数据结构。
   初始化队列

  //初始化三级队列
    MRLA_Queue queue0, queue1, queue2;
    init_queue(&queue0);
    init_queue(&queue1);
    init_queue(&queue2);

设置标志位

int count = 0, flag = 0, isExec = 0;//已进入就绪进程数,当前正在执行进程的队列级数，是否已执行

循环设置为按秒循环。

模拟进程进入就绪队列

//按当前时间执行入队操作
        if (count != num) {
            for (int i = count; i < num; ++i) {
                if (current_time == pcbdata[order[i]].time_start) {
                    p = malloc(sizeof(MRLA_Node));
                    p->handle = order[i];
                    p->time_slice = size0;
                    MRLA_push(&queue0, p);
                    count++;
                }
            }
        }

flag=1时，表示二级队列有进程正在执行，flag=2时，表示三级队列有进程正在执行通过queue判空实现将当前执行进程放在该队队末。

//当前执行二级队列，但有新来进程，对当前执行进程执行中断并放入所在队末
        if (flag == 1 && !isEmpty(queue0)) {
            p = MRLA_pop(&queue1);
            MRLA_push(&queue1, p);
        }
        //当前执行三级队列，但有新来进程，对当前执行进程执行中断并放入所在队末
        if (flag == 2 && (!isEmpty(queue0) || !isEmpty(queue1))) {
            p = MRLA_pop(&queue2);
            MRLA_push(&queue2, p);
        }

再通过isExec标志位判断当前秒是否已执行进程。在执行抢占式按单位时间执行方法。

        //一级队列
        if (!isEmpty(queue0)) {
            //执行队首，若队首时间片用完，弹出队首，压入下一级队列，并执行下一个
            if (!MRLA_exec(queue0.front->next, current_time, &isExec)) {

                queue0.front->next->time_slice = size1;
                p = MRLA_pop(&queue0);
                MRLA_push(&queue1, p);
                MRLA_exec(queue0.front->next, current_time, &isExec);
            }

            flag = 0;//当前正在执行进程的队列级数为0

            //若队列不为空，并状态为'E',则弹出队列
            if (!isEmpty(queue0) && pcbdata[queue0.front->next->handle].state == 'E') {
                p = MRLA_pop(&queue0);
                free(p);
            }
        }

        //二级队列
        if (!isExec && !isEmpty(queue1)) {

            //执行队首，若队首时间片用完，弹出队首，压入下一级队列，并执行下一个
            if (!MRLA_exec(queue1.front->next, current_time, &isExec)) {
                queue1.front->next->time_slice = size2;
                p = MRLA_pop(&queue1);
                MRLA_push(&queue2, p);
                MRLA_exec(queue1.front->next, current_time, &isExec);
            }

            flag = 1;//当前正在执行进程的队列级数为1

            //若队列不为空
            if (!isEmpty(queue1)) {

                if (queue1.front->next->time_slice == 0 || pcbdata[queue1.front->next->handle].state == 'E') {
                    flag = 0;//当前不执行进程
                }
                //状态为'E',则弹出队列
                if (pcbdata[queue1.front->next->handle].state == 'E') {
                    p = MRLA_pop(&queue1);
                    free(p);
                }
            }
        }

        if (!isExec && !isEmpty(queue2)) {

            //执行队首，若队首时间片用完，弹出队首，压入队末，并执行下一个
            if (!MRLA_exec(queue2.front->next, current_time, &isExec)) {
                queue2.front->next->time_slice = size2;
                p = MRLA_pop(&queue2);
                MRLA_push(&queue2, p);
                MRLA_exec(queue2.front->next, current_time, &isExec);
            }

            flag = 2;//当前正在执行进程的队列级数为2

            if (!isEmpty(queue2)) {
                if (queue2.front->next->time_slice == 0) {
                    flag = 0;//当前不执行进程
                }

                //状态为'E',则弹出队列
                if (pcbdata[queue2.front->next->handle].state == 'E') {
                    p = MRLA_pop(&queue2);
                    free(p);
                }
            }

        }
        current_time++;
        isExec = 0;

代码实现

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

typedef struct pcb PCB;
struct pcb {
    int id;
    char name[10];
    int time_start;
    int time_need;
    int time_left;
    int time_used;
    int time_exit;
    char state;
};

int num = 5;
PCB pcbdata[10] = {
        {1000, "A", 0, 4, 4, 0, 0, 'R'},
        {1001, "B", 1, 3, 3, 0, 0, 'R'},
        {1002, "C", 2, 5, 5, 0, 0, 'R'},
        {1003, "D", 3, 2, 2, 0, 0, 'R'},
        {1004, "E", 4, 4, 4, 0, 0, 'R'}
};

int ready[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int order[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

typedef struct MRLA_Node {
    int handle; //进程句柄
    int time_slice; //该进程时间片执行时间剩余量
    struct MRLA_Node *next;
} MRLA_Node;

typedef struct MRLA_Queue {
    struct MRLA_Node *front, *rear;
} MRLA_Queue;

//获取pcb数组
void input();

//打印进程完成表格
void my_printf();

//按需执行进程
int exec(int i, PCB *pcb, int current_time);

//获取响应比
float get_responseRatio(int current_time, PCB pcb);

//按秒执行进程
void exec_Slice(PCB *pcb, int
 current_time);

//----------------时间片的就绪队列操作---------------
//循环队列的出队操作
int RR_pop(int queue[], int *front, const int *rear);

//循环队列的入队操作
int RR_push(int queue[], const int *front, int *rear, int handle);
//-----------------------------------------------


//-----------------多级反馈队列操作----------------------
//初始化链式队列
void init_queue(MRLA_Queue *queue);

//链式队列的入队操作
void MRLA_push(MRLA_Queue *queue, MRLA_Node *p);

//链式队列的出队操作
MRLA_Node *MRLA_pop(MRLA_Queue *queue);

//判空操作
int isEmpty(MRLA_Queue queue);

//释放队列
void close(MRLA_Queue queue);

//可抢占式按秒执行
int MRLA_exec(MRLA_Node *node, int current_time, int *isExec);

//-----------------------------------------------

//先来先服务
void FCFS();

//短作业优先
void SJF();

//高响应比
void HRF();

//时间片
void Timeslice(int slice_size);

//三级反馈调度
void MRLA(int size0, int size1, int size2);

int main() {

    //模拟进程到来顺序
    for (int i = 0; i < num; i++) {
        for (int j = i + 1; j < num; j++) {
            if (pcbdata[order[i]].time_start > pcbdata[order[j]].time_start) {
                int s = order[i];
                order[i] = order[j];
                order[j] = s;
            }
        }
    }

    int sch = 99;

    while (sch != 0) {
        input();
        printf("1)FCFS\n");
        printf("2)SJF\n");
        printf("3)HRF\n");
        printf("4)Timeslice\n");
        printf("5)MRLA\n");
        printf("0)EXIT\n");
        scanf("%d", &sch);
        switch (sch) {
            case 1:
                FCFS();
                break;
            case 2:
                SJF();
                break;
            case 3:
                HRF();
                break;
            case 4:
                Timeslice(2);
                break;
            case 5:
                MRLA(2, 4, 8);
                break;
            case 0:
                break;
        }

    }


    return 0;
}

void input() {
    int i;
    printf("进程总数：");
    scanf("%d", &num);
    for (i
 = 0; i < num; i++) {
        pcbdata[i].id = 1000 + i;
        printf("第%d个进程名：", i + 1);
        scanf("%s", &pcbdata[i].name);
        printf("第%d个进程到达时间", i + 1);
        scanf("%d", &pcbdata[i].time_start);
        printf("第%d个进程服务时间", i + 1);
        scanf("%s", &pcbdata[i].time_need);

        pcbdata[i].time_left = pcbdata[i].time_need;
        pcbdata[i].time_used = 0;
        pcbdata[i].state = 'R';
    }
}

void my_printf() {
    printf("%s\t%s\t%s\t%s\t%s\t%s\t\n", "name", "time_start", "time_need", "time_exit","time_turnover","turnover_right");
    for (int i = 0; i < num; ++i) {
        printf("%s\t%d\t\t%d\t\t%d\t\t%d\t\t%lf\t\n", pcbdata[i].name, pcbdata[i].time_start, pcbdata[i].time_need,
               pcbdata[i].time_exit, pcbdata[i].time_exit - pcbdata[i].time_start,
               (float) (pcbdata[i].time_exit - pcbdata[i].time_start) / pcbdata[i].time_need);
    }
    printf("-----所有进程调度完毕---------\n");
}

int exec(int i, PCB *pcb, int current_time) {
    printf("\n第%d个进程--%s", i + 1, pcb->name);
    printf("到达时间--%d，服务时间--%d，\n", pcb->time_start, pcb->time_need);
    printf("第%d个进程正在运行......\n", i + 1);

    current_time += pcb->time_need;
    pcb->time_exit = current_time;

    printf("运行结束\n");
    int turnover_time = current_time - pcb->time_start;
    float turnover_right = (float) turnover_time / pcb->time_need;
    printf("完成时间--%d，周转时间--%d，带权周转时间--%.1f\n", current_time, turnover_time, turnover_right);

    return current_time;
}

//获取响应比
float get_responseRatio(int current_time, PCB pcb) {
    if (pcb.state == 'R') {
        return (float) (current_time - pcb.time_start + pcb.time_need) / pcb.time_need;
    }

    return 0;
}

//----------------时间片操作-------------------------------
void exec_Slice(PCB *pcb, int current_time) {

    printf("第%d秒%s运行\n", current_time, pcb->name);

    pcb->time_left--;
    pcb->time_used++;

    if (pcb->time_left == 0) {
        pcb->time_exit = current_time + 1;
   
     pcb->state = 'E';
    }

}

int RR_pop(int queue[], int *front, const int *rear) {
    if (*front == *rear) {
        return -1;
    }
    int p = *front;
    *front = (*front + 1) % (num + 1);
    return queue[p];
}

int RR_push(int queue[], const int *front, int *rear, int handle) {
    if (*front == (*rear + 1) % (num + 1)) {
        return -1;
    }
    queue[*rear] = handle;
    *rear = (*rear + 1) % (num + 1);

    return 1;
}

void init_queue(MRLA_Queue *queue) {
    queue->front = (MRLA_Node *) malloc(sizeof(MRLA_Node));
    queue->rear = queue->front;
}

void MRLA_push(MRLA_Queue *queue, MRLA_Node *p) {
    p->next = NULL;
    queue->rear->next = p;
    queue->rear = p;
}

MRLA_Node *MRLA_pop(MRLA_Queue *queue) {

    if (queue->front->next == NULL) {
        return NULL;
    }
    MRLA_Node *p = queue->front->next;
    queue->front->next = queue->front->next->next;
    if (queue->front->next == NULL) {
        queue->rear = queue->front;
    }
    return p;

}

int isEmpty(MRLA_Queue queue) {
 
   if (queue.front == queue.rear) {
        return 1;
    }
    return 0;
}

void close(MRLA_Queue queue) {
    free(queue.front);
    queue.front = NULL;
    queue.rear = NULL;
}

int MRLA_exec(MRLA_Node *node, int current_time, int *isExec) {
    if (node == NULL || node->time_slice == 0 || *isExec == 1) {
        return 0;
    }
    node->time_slice--;
    exec_Slice(&pcbdata[node->handle], current_time);
    *isExec = 1;
    return 1;
}

void FCFS() {
    //就绪数组按到来时间排列
    for (int i = 0; i < num; i++) {
        for (int j = i + 1; j < num; j++) {
            if (pcbdata[ready[i]].time_start > pcbdata[ready[j]].time_start) {
                int temp = ready[i];
                ready[i] = ready[j];
                ready[j] = temp;
            }
        }
    }


    printf("---------------先来先服务：非抢占，无时间片-------------------");
    int current_time = pcbdata[ready[0]].time_start;

    for (int i = 0; i < num;) {
        if (pcbdata[ready[i]].time_start <= current_time) {
            current_time = exec(i, &pcbdata[ready[i]], current_time);
            i++;
        } else {
            current_time++;
        }
    }
    my_printf();
}


void SJF() {

    //就绪数组按服务时间从短到长排列
    for (int i = 0; i < num; i++) {
        for (int j = i + 1; j < num; j++) {
            if (pcbdata[ready[i]].time_need > pcbdata[ready[j]].time_need) {
                int temp = ready[i];
                ready[i] = ready[j];
                ready[j] = temp;
            }
        }
    }

    printf("---------------短作业优先：非抢占，无时间片-------------------\n");
    int current_time = pcbdata[order[0]].time_start;
    int flag = 0; //标识在当前时间是否存在已到达进程

    for (int i = 0; i < num;) {

        //执行状态为'R'的已到达的服务时间最短的一个进程
        for (int j = 0; j < num; j++) {
            if (pcbdata[ready[j]].time_start <= current_time && pcbdata[ready[j]].state== 'R') {
                flag = 1;
                current_time = exec(i, &pcbdata[ready[j]], current_time);
        
        		pcbdata[ready[j]].state = 'E';
                i++;
                break;
            }
        }
        //无进程在此刻，时间按秒自加
        if (flag == 0) {
            current_time++;
        }
        flag = 0;
    }
    my_printf();
}


void HRF() {

    printf("---------------高响应比优先：非抢占，无时间片-------------------\n");
    int current_time = pcbdata[order[0]].time_start;

    for (int i = 0; i < num;) {

        //寻找在此刻响应比最高且已到达的未执行进程，并将其作为就绪数组之首
        for (int j = 0; j < num; j++) {
            if (get_responseRatio(current_time, pcbdata[ready[0]]) <
                get_responseRatio(current_time, pcbdata[ready[j]]) &&
                current_time >= pcbdata[ready[j]].time_start) {
                int temp = ready[j];
                ready[j] = ready[0];
                ready[0] = temp;
            }
        }

        //如果存在，执行进程，否则时间执行自加
        if (pcbdata[ready[0]].state == 'R') {
            current_time = exec(i, &pcbdata[ready[0]], current_time);
            pcbdata[ready[0]].state = 'E';
            i++;
        } else {
            current_time++;
        }
    }

    my_printf();
}


void Timeslice(int slice_size) {

    int front = 0, rear = 0;//循环队列头,尾指针

    printf("---------------时间片-------------------\n");
    int current_time = pcbdata[order[0]].time_start;
    int time = current_time; //用于将当前时间片执行时间归零

    int count = 0;//已进入就绪队列的个数

    while (front != rear || count != num) {

        if (count != num) {
            for (int i = count; i < num; ++i) {
                if (current_time == pcbdata[order[count]].time_start) {
                    RR_push(ready, &front, &rear, order[count]);
                    count++;
                }

            }
        }

        //判空
        if (front != rear) {
            exec_Slice(&pcbdata[ready[front]], current_time);
        }
        current_time++;

        //按时间片和执行时间片结束的进程的状态，执行出队操作，并由进程状态决定是否执行入队操作
        if ((current_time - time) % slice_size == 0 || pcbdata[ready[front]].state == 'E') {
            int x = RR_pop(ready, &front, &rear);
            if (pcbdata[x].state != 'E') {
                RR_push(ready, &front, &rear, x);
            } else {
                time = pcbdata[x].time_exit;
            }
        }
    }
    my_printf();
}


void MRLA(int size0, int size1, int size2) {
    //初始化三级队列
    MRLA_Queue queue0, queue1, queue2;
    init_queue(&queue0);
    init_queue(&queue1);
    init_queue(&queue2);


    printf("---------------多级反馈队列-------------------\n");
    int current_time = pcbdata[order[0]].time_start;
    int count = 0, flag = 0, isExec = 0;//已进入就绪进程数,当前正在执行进程的队列级数，是否已执行
    MRLA_Node *p;

    while (!isEmpty(queue0) || !isEmpty(queue1) || !isEmpty(queue2) || count != num) {
        //按当前时间执行入队操作
        if (count != num) {
            for (int i = count; i < num; ++i) {
                if (current_time == pcbdata[order[i]].time_start) {
                    p = malloc(sizeof(MRLA_Node));
                    p->handle = order[i];
                    p->time_slice = size0;
                    MRLA_push(&queue0, p);
                    count++;
                }
            }
        }
        //当前执行二级队列，但有新来进程，对当前执行进程执行中断并放入所在队末
        if (flag == 1 && !isEmpty(queue0)) {
            p = MRLA_pop(&queue1);
            MRLA_push(&queue1, p);
        }
        //当前执行三级队列，但有新来进程，对当前执行进程执行中断并放入所在队末
        if (flag == 2 && (!isEmpty(queue0) || !isEmpty(queue1))) {
            p = MRLA_pop(&queue2);
            MRLA_push(&queue2, p);
        }

        //一级队列
        if (!isEmpty(queue0)) {
            //执行队首，若队首时间片用完，弹出队首，压入下一级队列，并执行下一个
            if (!MRLA_exec(queue0.front->next, current_time, &isExec)) {

                queue0.front->next->time_slice = size1;
                p = MRLA_pop(&queue0);
                MRLA_push(&queue1, p);
                MRLA_exec(queue0.front->next, current_time, &isExec);
            }

            flag = 0;//当前正在执行进程的队列级数为0

            //若队列不为空，并状态为'E',则弹出队列
            if (!isEmpty(queue0) && pcbdata[queue0.front->next->handle].state == 'E') {
                p = MRLA_pop(&queue0);
                free(p);
            }
        }

        //二级队列
        if (!isExec && !isEmpty(queue1)) {

            //执行队首，若队首时间片用完，弹出队首，压入下一级队列，并执行下一个
            if (!MRLA_exec(queue1.front->next, current_time, &isExec)) {
                queue1.front->next->time_slice = size2;
                p = MRLA_pop(&queue1);
                MRLA_push(&queue2, p);
                MRLA_exec(queue1.front->next, current_time, &isExec);
            }

            flag = 1;//当前正在执行进程的队列级数为1

            //若队列不为空
            if (!isEmpty(queue1)) {

                if (queue1.front->next->time_slice == 0 || pcbdata[queue1.front->next->handle].state == 'E') {
                    flag = 0;//当前不执行进程
                }
                //状态为'E',则弹出队列
                if (pcbdata[queue1.front->next->handle].state == 'E') {
                    p = MRLA_pop(&queue1);
                    free(p);
                }
            }
        }

        if (!isExec && !isEmpty(queue2)) {

            //执行队首，若队首时间片用完，弹出队首，压入队末，并执行下一个
            if (!MRLA_exec(queue2.front->next, current_time, &isExec)) {
                queue2.front->next->time_slice = size2;
                p = MRLA_pop(&queue2);
                MRLA_push(&queue2, p);
                MRLA_exec(queue2.front->next, current_time, &isExec);
            }

            flag = 2;//当前正在执行进程的队列级数为2

            if (!isEmpty(queue2)) {
                if (queue2.front->next->time_slice == 0) {
                    flag = 0;//当前不执行进程
                }

                //状态为'E',则弹出队列
                if (pcbdata[queue2.front->next->handle].state == 'E') {
                    p = MRLA_pop(&queue2);
                    free(p);
                }
            }

        }
        current_time++;
        isExec = 0;
    }

    close(queue0);
    close(queue1);
    close(queue2);

    my_printf();
}