java开发系统内核：进程的挂起和恢复

更详细的讲解和代码调试演示过程，请参看视频
Linux kernel Hacker, 从零构建自己的内核

有了进程的自动调度后，接下来的任务在于，如何将空闲进程挂起，空闲进程往往是那些没有具体任务需要处理的进程，因此，如果继续让其运行的话，那么必然会耗费宝贵的CPU资源，如果能让它先挂起，等到它需要执行具体任务时，再把它调度到前台，那才是一种合理的进程管理机制。

我们实现的进程调度，是依赖于进程控制器，也就是taskctl中的任务数组来实现的，当我们想要启动某个进程时，在该数组中找到对应的任务对象，然后把它加载到CPU那就可以了。

同理，如果要让某个进程休眠，那么只要把它对应的TASK对象从任务数组中移除，那么它自然就不会得到调度的机会。

因此，修改multi_task.c 增加一个task_sleep函数：

void task_sleep(struct TASK *task) {
   int  i;
   char ts = 0;
   if (task->flags == 2) {
        if (task == taskctl->tasks[taskctl->now]) {
            ts = 1;
        }

    for (i = 0; i < taskctl->running; i++) {
        //在任务数组中找到要挂起的进程对象
        if (taskctl->tasks[i] == task) {
            break;
        }
    }

    taskctl->running--;
    if (i < taskctl->now) {
        taskctl->now--;
    }

    for(; i < taskctl->running; i++) {
        //通过把后面的任务往前覆盖，实现将当前任务从任务列表中移除的目的
        taskctl->tasks[i] = taskctl->tasks[i+1];
    }

    task->flags = 1;
    if (ts != 0) {
        //如果当前挂起的任务正好是当前正在前台运行的任务，那么将第0个任务调度到前台
        if (taskctl->now >= taskctl->running) {
            taskctl->now = 0;
        }

       farjmp(0, taskctl->tasks[taskctl->now]->sel);
    }

   }

   return;
}

该函数的逻辑是，根据要挂起的任务，在整个任务数组中查找，找到其对应的数组下标，然后把后面的任务向前覆盖，这样的话，要移除的任务就在数组中就会被覆盖掉，从而实现将任务从数组中移除的目的。

需要注意的是，如果要挂起的任务，正好是当前正在前台运行的进程，那么ts==1，我们就把下标为0的任务调度到前台，并且把任务的数量也就是running的值减一，这样，处于数组最后的那个任务将不会有机会被调度。

任务挂起是实现了，那么当我们想重新把任务调度到前台时，该怎么做呢？我们可以利用现有的队列机制，回忆一下，一旦鼠标，键盘的事件发生时，我们会把硬件产生的数据加入到他们对应的队列中，然后在CMain主循环中，将队列中的数据取出来处理。同理，当我们挂起一个任务时，我们把挂起的任务对象放入到一个队列中，当想要重新调度这个对象时，我们往队列里发送一个数据，然后在主循环中对该队列进行检查，一旦发现队列中含有数据的话，那么就把队列中寄存的任务重新加入调度数组。代码修改如下，在golbal_define.c中：

void fifo8_init(struct FIFO8 *fifo, int size, unsigned char *buf, 
    struct TASK *task) {
    fifo->size = size;
    fifo->buf = buf;
    fifo->free = size;
    fifo->flags = 0;
    fifo->p = 0;
    fifo->q = 0;
    fifo->task = task;
    return ;
}

在初始化一个队列时，把一个任务对象添加进去，如果队列不需要寄存任务对象，那么把task设置为0就可以。

int fifo8_put(struct FIFO8 *fifo, unsigned char data) {
    if (fifo == 0) {
        return -1;
    }    

    if (fifo->free ==0) {
        fifo->flags |= FLAGS_OVERRUN;
        return -1;
    }

    fifo->buf[fifo->p] = data;
    fifo->p++;
    if (fifo->p == fifo->size) {
        fifo->p = 0;
    }

    fifo->free--;

    if (fifo->task != 0) {
        if (fifo->task->flags != 2) {
            task_run(fifo->task);
        }
    }

    return 0;
}

当队列中有数据加入时，顺便查看该队列是否寄存着一个任务对象，如果是，那么把该任务对象加入调度数组。

由于timer.c中，对计时器的运行需要使用到队列，既然队列的数据结构有变动，因此timer.c中，需要做一点小改动：

static struct TIMERCTL timerctl;
extern struct TIMER *task_timer;

void  init_pit(void) {
    io_out8(PIT_CTRL, 0x34);
    io_out8(PIT_CNT0, 0x9c);
    io_out8(PIT_CNT0, 0x2e);

    timerctl.count = 0;
    int i;
    for (i = 0; i < MAX_TIMER; i++) {
        timerctl.timer[i].flags = 0; //not used
        timerctl.timer[i].fifo = 0;
    }
}

上面的改动在于，把每个timer对象的fifo队列成员设置为0。

接下来的改动主要在主入口函数中：

void CMain(void) {
    ....
    fifo8_init(&timerinfo, 8, timerbuf, 0);
    ....
    fifo8_init(&keyinfo, 32, keybuf, 0);
    ....
    task_a = task_init(memman);
    keyinfo.task = task_a;
    ....
}

上面代码的逻辑是，先通过task_init得到CMain函数所对应的任务对象，并把该任务对象寄存在键盘事件列表中，也就是keyinfo.task = task_a;

void CMain(void) {
    ....
    task_run(task_b);
    ...
    int pos = 0;
    int stop_task_A = 0;
     for(;;) {

       io_cli();
       ....
       else if (fifo8_status(&timerinfo) != 0) {
           io_sti();
           int i = fifo8_get(&timerinfo);
           if (i == 10) {
                showString(shtctl, sht_back, pos, 144, COL8_FFFFFF,
                 "A"); 

                timer_settime(timer, 100);
                pos += 8;
                if (pos > 40 && stop_task_A == 0) {
                    io_cli();
                    task_sleep(task_a);
                    io_sti();
                 }
           }
       ....
    }
}

上面代码的逻辑时，当CMain函数在主循环中，连续打印字符”A”,当打印的字符超过5个时，通过task_sleep(task_a)把CMain进程挂起。这样的话，系统运行时，我们会发现原来是字符A和B 是同时打印到桌面上的，此时便只剩下字符B在继续打印了。

由于我们把task_A寄存到键盘队列，那么当我们点击键盘，于是键盘数据就会存储到键盘队列中，由于键盘队列存储了任务Ad的任务对象，那么此时他会把对应任务对象重新加入到调度队列中，由此字符A会从恢复打印状态，也就是说，打印字符A的进程重新获得了被调度的机会。

参看视频，可以获得更加生动的演示展示。

更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：