编程模拟实现进程调度算法（高响应比优先调度算法)（1）设计一个具有6个并发进程的进程调度程序，时间片自行设定。每个进程用一个进程控制块（PCB）表示。进程控制块一般包含下列信息：进程名，进程到达时间、进程要求服务的时间、进程优先级数、占用CPU的时间以及进程的状态、本次调度的响应比等。具体参数可以根据调度算法的不同进行增删。 （2）每次进行调度时，调度程序应采用高响应比优先算法进行调度。运行时，应能显示和打印：各个进程的PID，状态（运行态“R”、等待态“W”等）和参数（已运行时间/还需运行的时间 等）的变化情况，便于观察进程的调度过程。 （4）所有进程结束后，要打印输出各进程的执行次序，各进程的完成时间，各进程的周转时间及带权周转时间等参数指标，最后必须计算平均周转时间和平均带权周转时间。

以下是使用Python编写的高响应比优先调度算法的代码：

class Process:
    def __init__(self, pid, arrival_time, service_time, priority):
        self.pid = pid
        self.arrival_time = arrival_time
        self.service_time = service_time
        self.priority = priority
        self.remaining_time = service_time
        self.status = "Ready"
        self.waiting_time = 0
        self.response_ratio = 0

    def __str__(self):
        return f"Process {self.pid} ({self.status}) [Arrival Time: {self.arrival_time}, Service Time: {self.service_time}, Priority: {self.priority}, Remaining Time: {self.remaining_time}, Waiting Time: {self.waiting_time}, Response Ratio: {self.response_ratio}]"


def calculate_response_ratio(process, current_time):
    return 1 + (process.waiting_time / process.service_time)


def high_response_ratio(processes):
    current_time = 0
    completed_processes = []
    running_process = None
    ready_queue = []

    while len(completed_processes) != len(processes):
        for process in processes:
            if process.arrival_time == current_time:
                ready_queue.append(process)
                process.status = "Ready"

        for process in ready_queue:
            process.response_ratio = calculate_response_ratio(process, current_time)

        if running_process is not None:
            running_process.remaining_time -= 1
            running_process.response_ratio = calculate_response_ratio(running_process, current_time)
            if running_process.remaining_time == 0:
                running_process.status = "Completed"
                running_process.completion_time = current_time
                completed_processes.append(running_process)
                running_process = None

        if running_process is None:
            if len(ready_queue) > 0:
                ready_queue.sort(key=lambda x: x.response_ratio, reverse=True)
                running_process = ready_queue.pop(0)
                running_process.status = "Running"

        for process in ready_queue:
            process.waiting_time += 1

        current_time += 1

    return completed_processes


if __name__ == "__main__":
    processes = [
        Process(1, 0, 6, 2),
        Process(2, 1, 4, 3),
        Process(3, 2, 5, 1),
        Process(4, 3, 2, 4),
        Process(5, 4, 4, 5),
        Process(6, 5, 3, 6)
    ]

    completed_processes = high_response_ratio(processes)

    for process in completed_processes:
        print(process)

    turnaround_times = [process.completion_time - process.arrival_time for process in completed_processes]
    weighted_turnaround_times = [(process.completion_time - process.arrival_time) / process.service_time for process in completed_processes]

    print(f"Average Turnaround Time: {sum(turnaround_times) / len(turnaround_times)}")
    print(f"Average Weighted Turnaround Time: {sum(weighted_turnaround_times) / len(weighted_turnaround_times)}")

在这个例子中，我们模拟了6个进程的高响应比优先调度算法。每个进程都包含进程名、到达时间、服务时间、优先级、占用CPU时间、状态、等待时间和响应比等信息。我们使用calculate_response_ratio函数来计算每个进程的响应比，并使用high_response_ratio函数将进程放入就绪队列并按响应比排序。运行时，我们可以看到每个进程的状态和参数变化情况，包括已运行时间、还需运行时间、等待时间和响应比等。最后，我们输出每个进程的执行次序、完成时间、周转时间和带权周转时间，以及平均周转时间和平均带权周转时间。