进程在CPU上的执行过程。要求每次进程调度时在屏幕上显示： 当前执行进程、就绪队列、等待队列。

进程在CPU上的执行过程分为以下几个步骤：

1. 进程被创建并加入到就绪队列中等待调度；
2. 调度器从就绪队列中选取一个进程并将其调度到CPU上执行；
3. 进程在CPU上执行，执行完毕后可能会进入等待队列等待资源（例如I/O）；
4. 当资源就绪后，等待队列中的进程会重新加入到就绪队列中等待调度；
5. 调度器再次从就绪队列中选取一个进程并将其调度到CPU上执行，如此循环。

每次进程调度时，在屏幕上显示当前执行进程、就绪队列、等待队列的信息，可以帮助我们更好地了解进程的执行状态。

具体实现方法如下：

1. 定义一个进程结构体，包含进程的ID、状态等信息；
2. 定义就绪队列和等待队列，使用链表或数组来实现；
3. 定义一个函数来显示当前执行进程、就绪队列、等待队列的信息，每次调度时调用该函数即可；
4. 在进程的创建、调度、等待和唤醒等操作中，不断更新就绪队列和等待队列的信息，并调用显示函数更新屏幕上的信息。

示例代码如下所示：

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

// 进程状态
typedef enum {
    READY, RUNNING, WAITING
} ProcessState;

// 进程结构体
typedef struct {
    int id; // 进程ID
    ProcessState state; // 进程状态
} Process;

// 就绪队列和等待队列
Process readyQueue[10];
int readyQueueSize = 0;
Process waitingQueue[10];
int waitingQueueSize = 0;

// 显示当前执行进程、就绪队列、等待队列的信息
void showStatus(Process* runningProcess) {
    // 显示当前执行进程
    printf("Running process: %d\n", runningProcess->id);
    // 显示就绪队列
    printf("Ready queue: ");
    for (int i = 0; i < readyQueueSize; i++) {
        printf("%d ", readyQueue[i].id);
    }
    printf("\n");
    // 显示等待队列
    printf("Waiting queue: ");
    for (int i = 0; i < waitingQueueSize; i++) {
        printf("%d ", waitingQueue[i].id);
    }
    printf("\n");
}

// 创建进程
Process* createProcess(int id) {
    Process* process = (Process*) malloc(sizeof(Process));
    process->id = id;
    process->state = READY;
    // 加入就绪队列
    readyQueue[readyQueueSize++] = *process;
    return process;
}

// 调度进程
Process* scheduleProcess() {
    // 从就绪队列中选取一个进程
    if (readyQueueSize > 0) {
        Process* process = &readyQueue[0];
        process->state = RUNNING;
        // 从就绪队列中移除
        for (int i = 1; i < readyQueueSize; i++) {
            readyQueue[i - 1] = readyQueue[i];
        }
        readyQueueSize--;
        return process;
    }
    return NULL;
}

// 进程等待
void waitProcess(Process* process) {
    // 加入等待队列
    process->state = WAITING;
    waitingQueue[waitingQueueSize++] = *process;
}

// 唤醒进程
void wakeupProcess(Process* process) {
    // 从等待队列中移除
    for (int i = 0; i < waitingQueueSize; i++) {
        if (waitingQueue[i].id == process->id) {
            for (int j = i + 1; j < waitingQueueSize; j++) {
                waitingQueue[j - 1] = waitingQueue[j];
            }
            waitingQueueSize--;
            break;
        }
    }
    // 加入就绪队列
    process->state = READY;
    readyQueue[readyQueueSize++] = *process;
}

int main() {
    // 创建进程
    Process* process1 = createProcess(1);
    Process* process2 = createProcess(2);
    Process* process3 = createProcess(3);
    // 调度进程
    Process* runningProcess = scheduleProcess();
    // 显示进程状态
    showStatus(runningProcess);
    // 进程等待
    waitProcess(process2);
    // 唤醒进程
    wakeupProcess(process2);
    // 调度进程
    runningProcess = scheduleProcess();
    // 显示进程状态
    showStatus(runningProcess);
    return 0;
}