最近刚刚做的一个课程设计，关于SPOOLing的。

一、算法或原理的实现思想
技术原理
SPOOLing技术可将一台物理I/O设备虚拟为多台逻辑I/O设备，同样允许多个用户共享一台物理I/O设备。SPOOLing技术把所有用户进程的输出都送入输出井，然后再由输出进程完成打印工作，而输出井在磁盘上为共享设备。这样，SPOOLing技术就把打印机等独占设备改造成立共享设备。由于SPOOLing技术实现了多个用户进程共同使用打印机这种独占设备的情况，从而实现了把一个设备当成多个设备来使用，即虚拟设备的功能。SPOOLing技术有输入输出井，输入缓冲区和输出缓冲区，输入进程和输出进程，请求打印队列组成输入输出井，用来收集输入设备输入的数据，输入井模拟脱机输入时的磁盘。输出井是收集用户程序的输出数据。输入缓存区由输入设备送来的数据以后再送入输入井，输出缓存区用来暂存从输入井送来的数据，以后再送给输出设备。输入进程模拟脱机输入时的外围控制机，将用户要求的数据从输入设备，通过输入缓冲区送到输入井。当CPU需要数据时，直接从输入井读入主存；输出进程模拟脱机输出时的外围控制机，把用户要求输出的数据，先从主存送到输出井，待输出设备空闲时，再将输出井中的数据，经过输出缓冲区送到输出设备上。由若干张请求打印表所形成的队列，系统为每个请求打印的进程建立一张请求打印表。然后逐个执行，保证所有请求都被完成。

重要思想
核心思想：是以联机的方式得到脱机的效果
OS的四大特性之一：虚拟性
二、程序

#include <cstdio>
#include <time.h>
#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
using namespace std;
宏定义，基本量
#define READY_STATUS                0//就绪状态
#define WAIT_BUFFER_STATUS          1//等待状态1，表示输出井满，请求输出的用户进程等待；
#define WAIT_REQUEST_STATUS         2//等待状态2，表示请求输出井空，SP00LING输出进程等待；
#define WAIT_REQBLOCK_STATUS        3//等待状态3，表示请求输出井满，请求输出的用户进程等待；
#define FINISH_STATUS               4//结束态，进程执行完成。
#define RUN_STATUS                  5//运行态，表示正在运行

struct PCB {
    int id;         //进程标识数
    int status;     //进程状态
    int count;      //要输出的文件数
    int tmp_x;      //进程输出时的临时变量
}pcb[3];

int FINISH_STATUS_PCB_CNT;//处于结束态的进程个数

//请求输出块reqblock
struct Reqblock{
    int reqname;//请求进程名
    int length; //本次输出信息长度
    int addr;   //信息在输出井的首地址
}reqblock[10];

int buffer[2][100]; //两个输出井
int EMPTY_BUF_COUNT[2];  //分别表示两个用户进程可使用的输出井的空间

int BUF_BEGIN[2];//buffer[i]的第一个满缓冲指针
int BUF_END[2];//buffer[i]的第一个空缓冲指针

int REQBLOCK_COUNT;//请求块结构也有一个计数器
int ptr_begin,ptr_end;//表示请求输出块使用情况

void user_thread0();//用户进程0
void user_thread1();//用户进程1
void spooling(int pid);//将用户进程输出送入输出井,将输出井数据输出到显示器
int schedule();//调度进程


double random() { //生成0~1随机数
    static double Seed = 233;  //随机种子，在此处可改变初值
    Seed = 125.0 * (Seed + 1.0);
    Seed = Seed - 8192.0 * (int)(Seed/8192);
    return (Seed+0.5)/8192;
}


void init() {
    //对各进程的PCB、输出请求快、输出井初始化
    for (int i = 0; i < 3; i++) {
        pcb[i].id = i;
        pcb[i].status = READY_STATUS;
    }
    pcb[2].status = WAIT_REQUEST_STATUS;
    for (int i = 0; i < 10; i++) {
        reqblock[i].reqname = -1;
        reqblock[i].length = 0;
        reqblock[i].addr = 0;
    }
    EMPTY_BUF_COUNT[0] = EMPTY_BUF_COUNT[1] = 100;

    BUF_BEGIN[0] = BUF_END[0] = 0;
    BUF_BEGIN[1] = BUF_END[1] = 1;
    REQBLOCK_COUNT = 10;
    ptr_begin = ptr_end = 0;

    for (int i = 0 ;i < 2; i++) {
        printf("输入进程%d申请Output文件个数:\n",i);
        scanf("%d",&pcb[i].count);
    }
    FINISH_STATUS_PCB_CNT = 0;
}

void user_thread0() {
    pcb[0].tmp_x =  static_cast<int>(random()*10);
    //cout <<"第0号进程申请输出"<<pcb[0].tmp_x<<"\n";
    pcb[0].status = RUN_STATUS;
    spooling(0);
}

void user_thread1() {
    pcb[1].tmp_x = static_cast<int>(random()*10);
    //cout <<"第1号进程申请输出"<<pcb[1].tmp_x<<"\n";
    pcb[1].status = RUN_STATUS;
    spooling(1);
}


void spooling(int pid) {
    if(pid!=-1)
    {

        while (EMPTY_BUF_COUNT[pid] == 0) {
        printf("输出井已满,进程%d等待\n",pid);
        pcb[pid].status = WAIT_BUFFER_STATUS;
        //转spooling
        spooling(-1);
    }

    buffer[pid][BUF_END[pid]] = pcb[pid].tmp_x;//修改空缓冲区
//printf("buff[%d][%d]=%d\n",pid,BUF_END[pid],pcb[pid].tmp_x);
    BUF_END[pid]++;
    if (BUF_END[pid] == 100)
        BUF_END[pid] = 0;
    EMPTY_BUF_COUNT[pid]--;

    if (pcb[pid].tmp_x == 0) { //一个文件输出结束
        printf("进程%d完成一个文件\n",pid);
        while (REQBLOCK_COUNT == 0) {
            printf("进程%d输出因缺少空闲请求块等待\n",pid);
            pcb[pid].status = WAIT_REQBLOCK_STATUS;
            spooling(-1);
        }
        //将文件在输出井的位置和长度填入空闲请求块
        reqblock[ptr_end].reqname = pid;
        reqblock[ptr_end].addr = BUF_BEGIN[pid];
        reqblock[ptr_end].length = BUF_END[pid]>BUF_BEGIN[pid] ? BUF_END[pid]-BUF_BEGIN[pid] :
                                                                 100+BUF_END[pid]-BUF_BEGIN[pid];
        printf("空闲请求块申请成功，位置:%d,长度%d\n",reqblock[ptr_end].addr,reqblock[ptr_end].length);
        ptr_end++;
        BUF_BEGIN[pid] = BUF_END[pid];
        if (ptr_end == 10)
            ptr_end = 0;
        REQBLOCK_COUNT--;//空闲请求块数减1
        if (pcb[2].status == WAIT_REQUEST_STATUS) {//SPOOLING进程是等待状态
            //唤醒SPOOLING进程
             pcb[2].status = RUN_STATUS;
           //  thread(spooling).join();
             spooling(-1);
        }

        pcb[pid].count--;//完成一个文件

            cout << "进程" << pid << "完成一个文件，还剩" << pcb[pid].count << "个文件\n";
        if (pcb[pid].count == 0) {
            pcb[pid].status = FINISH_STATUS;
            FINISH_STATUS_PCB_CNT++;

               cout << "进程" << pid << "运行结束\n";
            //进程i运行结束
            return;//转进程调度
        } else {
            //本文件未结束，继续输出
            if (pid==0)
                user_thread0();
            else
                user_thread1();
        }
    } else {
       //还有其他文件输出
      if (pid==0)
        user_thread0();
      else
        user_thread1();
    }
    }
    else
    {
        cout<<"spooling输出\n";
         int pid = 2;
    pcb[pid].status = RUN_STATUS;
    if (REQBLOCK_COUNT == 10) {//请求输出块空
        cout<<"spooling请求输出块空\n";
        if (pcb[0].status==FINISH_STATUS && pcb[1].status==FINISH_STATUS) {//两个请求输出的进程结束了
            pcb[pid].status = FINISH_STATUS;
            FINISH_STATUS_PCB_CNT++;
            //SPOOLING进程结束
            puts("任务结束");
            return;
        }
        else {
            pcb[pid].status = WAIT_REQUEST_STATUS;
            puts("无申请块,SPOOLING进程等待");
            return;//SPOOLING进程等待
        }
    }

    int buf_begin = reqblock[ptr_begin].addr;
    int buf_end = (buf_begin + reqblock[ptr_begin].length)%100;
    int userpid = reqblock[ptr_begin].reqname;

    printf("下面是来自进程%d的输出:\n",userpid);
    for (int i = buf_begin; i != buf_end; i=(i+1)%100)
        printf("%d ",buffer[userpid][i]);
    puts("");
    puts("spooling输出完成");
    EMPTY_BUF_COUNT[userpid] += reqblock[ptr_begin].length;//释放输出井空间
    for (int i = 0; i < 2; i++)
        if (pcb[i].status == WAIT_BUFFER_STATUS) {
            pcb[i].status = RUN_STATUS;//唤醒相应进程
            printf("进程%d又可以执行了\n",userpid);
         }
    ptr_begin++;//释放该请求输出块
    if (ptr_begin == 10)
        ptr_begin -= 10;
    REQBLOCK_COUNT++;
    for (int i = 0; i < 2; i++)
        if (pcb[i].status == WAIT_REQBLOCK_STATUS) {
            pcb[i].status = RUN_STATUS;//唤醒相应进程
            printf("进程%d又可以执行了\n",userpid);
        }

    pcb[pid].status = READY_STATUS;
    }

}


int schedule() {
    float rand_num =random();
    if (rand_num <= 0.45 && pcb[0].status==READY_STATUS) {
        puts("调度程序:调用用户进程0");
        user_thread0();
        return 0;
    }
    if (rand_num <= 0.9 && pcb[1].status==READY_STATUS) {
        puts("调度程序:调用用户进程1");
        user_thread1();
        return 1;
    }
    if (pcb[2].status == READY_STATUS) {
        puts("调度程序:调用spooling");
        spooling(-1);
        return 2;
    }
    return -1;
}
int main() {
    init();//对各进程的PCB、输出请求快、输出井初始化
    while (FINISH_STATUS_PCB_CNT < 3) {
        schedule();
    }
    return 0;
}

三、程序的输入和输出
测试数据1：
输入样例：
输出样例：

五、感想、体会或收获
这一次课程设计度让我学到了在平时课堂不可能学到的东西。我对这一次课程设计的机会非常珍惜。不一定我的课程设计能够完成得有多么完美，但是我很投入的去研究去学习。完成一个任务我非常开心。一开始任务是任务，到后面任务就成了自己的作品了。总结一下有以下体会。
1、网络真的很强大，用在学习上将是一个非常高效的助手。几乎所有的资料都能够在网上找到。包括相关技术原理，以及讲解的视频，真的很好，B站等，让我学习起来没有那么吃力，整个课程设计下来，我浏览的相关网页非常多。当然网上的东西很乱很杂，自己要能够学会筛选。不能决定对或错的，有个很简单的方法就是去尝试
2、同学间的讨论，这是很重要的。老师毕竟比较忙，或者有时候不好意思麻烦老师。对于课程设计最大的讨论伴侣应该是同学了。和自己班上同学讨论让自己受益匪浅。大家都在研究类似的问题，讨论起来，更能够把思路理清楚，相互帮助提高，可以大大提高效率。
3、敢于攻坚，越是难的问题，越是要有挑战的心理。这样就能够达到废寝忘食的境界。当然这也是不提倡熬夜的，毕竟有了精力才能够打持久战。但是做课设一定要有状态，能够在吃饭，睡觉，上厕所都想着要解决的问题，这样你不成功都难。
4、最好在做课设的过程中能够有记录的习惯，这样在写实验报告时能够比较完整的回忆起中间遇到的各种问题。比如当时我遇到我以前从未遇到过的错误，让我都不知道从何下手。在经过大量的资料查阅之后，我对错误有了一定的了解，并且能够用相应的办法来解决。
5.总而言之我认为操作系统是一门实践性很强的课程，这学期虽然在王老师精心教导下，对OS的理论掌握的很好，但是因为没有实训，所以在实践方面还是比较差的，而老师的这一次实训，很好的起到了一定的弥补作用，十分感激老师的用心良苦，在假期我打算去实现所有的课程设计任务，来更加提高对课程的理解深度，让自己变得越来越好。