编写并调度一个基于先来先服务的多道程序系统的作业调度模拟承租

首先，先来先服务（FCFS）是一种非抢占式的调度算法，即按照作业进入就绪队列的先后顺序进行调度，先进入就绪队列的作业先被执行，直到执行完毕或等待I/O或阻塞，才执行下一个作业。下面是一个基于先来先服务的多道程序系统的作业调度模拟承租的实现：

1. 定义作业结构体：

struct Job {
    int id; // 作业编号
    int arrival_time; // 到达时间
    int execution_time; // 执行时间
    int remaining_time; // 剩余执行时间
    int finish_time; // 完成时间
    int turnaround_time; // 周转时间
    int waiting_time; // 等待时间
};

2. 定义作业队列：

queue<Job> job_queue; // 作业队列

3. 定义进程结构体：

struct Process {
    int id; // 进程编号
    Job job; // 作业
};

4. 定义进程队列：

queue<Process> process_queue; // 进程队列

5. 定义时间片大小：

const int time_slice = 1; // 时间片大小为1个时间单位

6. 定义当前时间：

int current_time = 0; // 当前时间从0开始

7. 定义作业到达函数：

void job_arrival() {
    // 判断是否还有作业未到达
    if (!job_queue.empty() && job_queue.front().arrival_time == current_time) {
        // 如果有作业到达，则将该作业放入进程队列中
        Process process;
        process.id = process_queue.size() + 1;
        process.job = job_queue.front();
        process_queue.push(process);
        cout << "作业" << job_queue.front().id << "到达，进程" << process.id << "开始执行" << endl;
        job_queue.pop();
    }
}

8. 定义进程执行函数：

void process_execution() {
    // 判断进程队列是否为空
    if (!process_queue.empty()) {
        // 如果进程队列不为空，则取出队首进程进行执行
        Process process = process_queue.front();
        process.job.remaining_time -= time_slice;
        if (process.job.remaining_time <= 0) {
            // 如果进程执行完毕，则计算各项指标并输出
            process.job.finish_time = current_time;
            process.job.turnaround_time = process.job.finish_time - process.job.arrival_time;
            process.job.waiting_time = process.job.turnaround_time - process.job.execution_time;
            cout << "进程" << process.id << "执行完毕，作业" << process.job.id << "完成，周转时间：" << process.job.turnaround_time << "，等待时间：" << process.job.waiting_time << endl;
            process_queue.pop();
        }
        else {
            // 如果进程未执行完毕，则将其放回队尾
            process_queue.pop();
            process_queue.push(process);
        }
    }
}

9. 定义主函数：

int main() {
    // 输入作业数量和每个作业的信息
    int n;
    cout << "请输入作业数量：";
    cin >> n;
    for (int i = 1; i <= n; i++) {
        Job job;
        job.id = i;
        cout << "请输入作业" << i << "的到达时间和执行时间：";
        cin >> job.arrival_time >> job.execution_time;
        job.remaining_time = job.execution_time;
        job_queue.push(job);
    }
    // 执行作业调度模拟
    while (!job_queue.empty() || !process_queue.empty()) {
        job_arrival(); // 判断作业是否到达
        process_execution(); // 执行进程
        current_time += time_slice; // 时间片加1
    }
    return 0;
}

以上就是一个基于先来先服务的多道程序系统的作业调度模拟承租的实现。可以根据实际需要进行修改和扩展。