设计一段程序来模拟先来先服务，短作业优先、优先级调度算法和时间片轮转算法，要求可以根据不同调度算法，指定进程的数量、各进程的到达时间、各进程需要CPU的时间和各进程的优先级。

为了模拟这些调度算法，我们可以设计一个简单的Python程序，它会使用队列数据结构来存储待处理的任务，并根据选择的调度策略来进行任务分配。以下是基本的伪代码框架：

import heapq

class Process:
    def __init__(self, pid, arrival_time, cpu_time, priority):
        self.pid = pid
        self.arrival_time = arrival_time
        self.cpu_time = cpu_time
        self.priority = priority

class Scheduler:
    def __init__(self, process_list, scheduling_algorithm='FCFS'):
        self.processes = process_list
        self.scheduling_algorithm = scheduling_algorithm
        self.heap = []
    
    def run(self):
        # 根据调度算法填充堆或按照到达时间排序
        if self.scheduling_algorithm == 'FCFS':
            self.heap = sorted(self.processes, key=lambda x: x.arrival_time)
        elif self.scheduling_algorithm == 'SJF':
            self.heap = [(-p.cpu_time, p) for p in self.processes]
            heapq.heapify(self.heap)
        elif self.scheduling_algorithm == 'Priority':
            self.heap = sorted(self.processes, key=lambda x: x.priority, reverse=True)
        else:   # 时间片轮转
            self.heap = [Process(p.pid, p.arrival_time, p.cpu_time, p.priority) for p in self.processes]
        
        while self.heap:
            current_process = heapq.heappop(self.heap)[1]  # 获取最高优先级或最早到达的进程
            print(f"Processing {current_process.pid} ({current_process.arrival_time})")
            # 模拟CPU运行
            # ...

            # 如果有剩余时间，放回堆中等待下一轮
            if current_process.cpu_time > 0:
                heapq.heappush(self.heap, (current_process.arrival_time + current_process.cpu_time, current_process))

# 示例使用
processes = [
    Process(1, 0, 10, 3),  # 到达时间, CPU时间, 优先级
    Process(2, 5, 5, 1),
    Process(3, 2, 8, 2),
]

scheduler = Scheduler(processes, 'SJF')
scheduler.run()

这个程序中，用户可以通过`Scheduler`类的构造函数传入不同类型的调度算法（如上面提到的FCFS，SJF，优先级，以及默认的简单时间片轮转）。每个进程包含PID、到达时间、CPU时间和优先级。`run()`方法将根据所选的算法执行调度。