1）使用优先数调度算法完成进程的调度 1) 采用动态优先数法确定进程的优先级别。 2) 设计三个链队列，分别用来表示运行队列、就绪队列和完成队列。 3) 用户输入进程标识符以及进程所需要的时间，申请空间存放进程 PCB 信息。 优先数调度算法为每个进程设一个优先数，它总是把处理机分配给就绪队列中具有最高优先权 的进程。常用的算法有静态优先数法和动态优先数法。 动态优先数法使进程的优先权随时间而改变。初始的进程优先数取决于进程运行所需要的时 间，时间长则优先数低。可采取将进程优先数定为一个较大的数（比如 50）减去进程运行所需要 的时间。 随着进程的运行对优先数进行调整，每次运行时都是从就绪队列中选取优先数最大的进程运 行。以一个时间片为固定周期 T，每个周期动态调整各个进程的优先级，当前正在执行的进程优先 级降低（优先数减小），所有就绪进程优先级提升（优先数增加），每个时间片开始时，重新选择当 前优先级最高的进程投入运行。如果进程所需时间为 0，说明进程运行完毕，将其状态变为完成状 态“F”，将此进程 PCB 插入到完成队列中。重复上述过程，直到就绪队列为空，所有进程都变为 完成状态为止。使用java语言实现

对于这个问题，我们需要分别实现进程控制块（PCB）和队列，然后使用优先数调度算法来完成进程的调度。下面是一个简单的Java代码示例：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class PriorityScheduling {
    static class PCB {
        String pid;
        int priority;
        int burstTime;
        int waitingTime;
        int turnaroundTime;
        int remainingTime;

        PCB(String pid, int priority, int burstTime) {
            this.pid = pid;
            this.priority = priority;
            this.burstTime = burstTime;
            this.waitingTime = 0;
            this.turnaroundTime = 0;
            this.remainingTime = burstTime;
        }
    }

    static class QueueNode {
        PCB pcb;
        QueueNode next;

        QueueNode(PCB pcb) {
            this.pcb = pcb;
            this.next = null;
        }
    }

    static class Queue {
        QueueNode front;
        QueueNode rear;

        Queue() {
            this.front = null;
            this.rear = null;
        }

        boolean isEmpty() {
            return front == null;
        }

        void enqueue(PCB pcb) {
            QueueNode node = new QueueNode(pcb);
            if (rear == null) {
                front = node;
                rear = node;
            } else {
                rear.next = node;
                rear = node;
            }
        }

        PCB dequeue() {
            if (isEmpty()) {
                return null;
            } else {
                PCB pcb = front.pcb;
                front = front.next;
                if (front == null) {
                    rear = null;
                }
                return pcb;
            }
        }

        PCB peek() {
            if (isEmpty()) {
                return null;
            } else {
                return front.pcb;
            }
        }
    }

    public static void main(String[] args) {
        Queue readyQueue = new Queue();
        Queue runningQueue = new Queue();
        Queue finishedQueue = new Queue();

        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入进程数量：");
        int n = scanner.nextInt();

        for (int i = 1; i <= n; i++) {
            System.out.print("请输入进程" + i + "的标识符、优先级和所需时间：");
            String pid = scanner.next();
            int priority = scanner.nextInt();
            int burstTime = scanner.nextInt();
            PCB pcb = new PCB(pid, priority, burstTime);
            readyQueue.enqueue(pcb);
        }

        int timeSlice = 1;
        while (!readyQueue.isEmpty() || !runningQueue.isEmpty()) {
            // 优先数调度算法
            if (!runningQueue.isEmpty()) {
                PCB pcb = runningQueue.peek();
                pcb.remainingTime -= timeSlice;
                pcb.priority--;
                if (pcb.remainingTime == 0) {
                    pcb.turnaroundTime += timeSlice;
                    pcb.waitingTime = pcb.turnaroundTime - pcb.burstTime;
                    finishedQueue.enqueue(pcb);
                    runningQueue.dequeue();
                } else {
                    runningQueue.dequeue();
                    readyQueue.enqueue(pcb);
                }
            }

            if (!readyQueue.isEmpty()) {
                PCB pcb = readyQueue.peek();
                QueueNode node = readyQueue.front;
                while (node != null) {
                    node.pcb.priority++;
                    node = node.next;
                }
                readyQueue = new Queue();
                while (!node.isEmpty()) {
                    PCB tmpPcb = node.dequeue();
                    readyQueue.enqueue(tmpPcb);
                }
                if (runningQueue.isEmpty() || (runningQueue.peek().priority < pcb.priority)) {
                    readyQueue.dequeue();
                    runningQueue.enqueue(pcb);
                }
            }
        }

        // 输出结果
        System.out.println("进程\t优先级\t所需时间\t等待时间\t周转时间");
        while (!finishedQueue.isEmpty()) {
            PCB pcb = finishedQueue.dequeue();
            System.out.println(pcb.pid + "\t" + pcb.priority + "\t" + pcb.burstTime + "\t" + pcb.waitingTime + "\t" + pcb.turnaroundTime);
        }
    }
}

在这个示例中，我们使用了动态优先数法来确定进程的优先级别，并且使用了三个链队列来表示运行队列、就绪队列和完成队列。用户需要输入进程标识符以及进程所需要的时间，然后我们申请空间存放进程 PCB 信息。每次运行时都是从就绪队列中选取优先数最大的进程运行，并且如果进程所需时间为 0，说明进程运行完毕，将其状态变为完成状态“F”，将此进程 PCB 插入到完成队列中。最后输出每个进程的等待时间和周转时间。