Python高级编程之生成器(Generator)与coroutine(四):一个简单的多任务系统

啊，终于要把这一个系列写完整了，好高兴啊

在前面的三篇文章中介绍了Python的Python的Generator和coroutine(协程)相关的编程技术，接下来这篇文章会用Python的coroutine技术实现一个简单的多任务的操作系统

代码如下，可看注释

#-*-coding:utf-8 -*-
'''
用Python和coroutine实现一个简单的多任务系统
'''
# ##Step 1:Define Tasks###################################
import select
class Task(object):
    taskid = 0

    def __init__(self,target):
        Task.taskid += 1
        self.tid = Task.taskid    # Task id
        self.target = target      # Target coroutine
        self.sendval = None       # Value to send

    def run(self):
        return self.target.send(self.sendval)
# ###############################################

# ##Step 2:The Scheduler#########################
import Queue
class Scheduler(object):
    def __init__(self):
        self.ready = Queue.Queue()
        self.taskmap = {}

        # 正在等待的Tasks,key是taskid
        self.exit_waiting = {}

        # 异步IO
        # Holding areas for tasks blocking on I/O.These are
        # dictionaries mapping file descriptions to tasks
        # 键值为文件描述符
        self.read_waiting = {}
        self.write_waiting = {}


    def iotask(self):
        while True:
            if self.ready.empty():
                # 如果ready为空，表示没有正在等待执行的队列
                # timeout 为None,表示不关心任何文件描述符的变化
                self.iopool(None)
            else:
                # ready不为空，则设置select函数不管文件描述符是否发生变化都立即返回
                self.iopool(0)
            yield


    def new(self,target):
        newtask = Task(target)
        self.taskmap[newtask.tid] = newtask
        self.schedule(newtask)
        return newtask.tid

    def schedule(self,task):
        # 把task放到任务队列中去
        self.ready.put(task)

    def exit(self,task):
        print "Task %d terminated" %task.tid
        del self.taskmap[task.tid]
        # Notify other tasks waiting for exit
        # 把正在等待的任务加入到正在执行的队列中去
        for task in self.exit_waiting.pop(task.tid,[]):
            self.schedule(task)

    def waitforexit(self,task,waittid):
        '''
        让一个任务等待另外一个任务，把这个任务加入到exit_waiting中去
        返回True表示这个task正在等待队列中
        '''
        if waittid in self.taskmap:
            self.exit_waiting.setdefault(waittid,[]).append(task)
            return True
        else:
            return False


    def waitforread(self,task,fd):
        '''
        functions that simply put a task into to
        one of the above dictionaries
        '''
        self.read_waiting[fd] = task

    def waitforwrite(self,task,fd):
        self.write_waiting[fd] = task

    def iopool(self,timeout):
        '''
        I/O Polling.Use select() to determine which file
        descriptors can be used.Unblock any associated task
        '''
        if self.read_waiting or self.write_waiting:
            # 获取I/O事件,一旦获取到，就放入到执行队列中取，等待执行
            r,w,e = select.select(self.read_waiting,
                                  self.write_waiting,[],timeout)
            for fd in r:
                self.schedule(self.read_waiting.pop(fd))

            for fd in w:
                self.schedule(self.write_waiting.pop(fd))

    def mainloop(self):
        self.new(self.iotask())  # Launch I/O polls
        while self.taskmap:
            task = self.ready.get()
            try:
                result = task.run()
                # 如果task执行的是System call，则对当前环境进行保存
                # 然后在执行System Call
                if isinstance(result,SystemCall):
                    # 把当前的环境保存，即保存当前运行的task和sched
                    result.task = task
                    result.sched = self
                    result.handle()
                    continue
            except StopIteration:
                self.exit(task)
                # print("task is over")
                continue
            self.schedule(task)
# ##Step 2:The Scheduler#########################


# ##SystemCall#########################
class SystemCall(object):
    '''
    所有系统调用的基类，继承自该类的类要重写handle函数
    '''
    def handle(self):
        pass


class GetTid(SystemCall):
    '''
    获取任务ID
    '''
    def handle(self):
        self.task.sendval = self.task.tid
        self.sched.schedule(self.task)


class NewTask(SystemCall):
    '''
    新建一个Task
    '''
    def __init__(self,target):
        self.target = target

    def handle(self):
        # 在这里把target封装成Task
        # 是在这里把新生成的task加入到执行队列当中去
        tid = self.sched.new(self.target)
        self.task.sendval = tid
        # 把执行这个系统调用的父task重新加入到执行队列中去
        # 这一点很关键，因为判断一个task是否结束是通过taskmap的
        # 这个task只是暂时被挂起,要重新放到queue中去
        self.sched.schedule(self.task)

class KillTask(SystemCall):
    '''
    杀死一个Task
    '''
    def __init__(self,tid):
        self.tid = tid

    def handle(self):
        task = self.sched.taskmap.get(self.tid,None)
        # task指的是要被kill掉的那个task
        # self.task指的是发起KillTask这个系统调用task
        if task:
            task.target.close()
            self.task.sendval = None
        else:
            self.task.sendval = False
        # target.close()只是产生一个StopIteration异常
        self.sched.schedule(self.task)


class WaitTask(SystemCall):
    '''
    让任务进行等待 系统调用
    '''
    def __init__(self,tid):
        self.tid = tid

    def handle(self):
        result = self.sched.waitforexit(self.task,self.tid)
        self.task.sendval = result
        # 如果等待的是一个不存在的task，则立即返回
        if not  result:
            self.sched.schedule(self.task)




class ReadWait(SystemCall):
    '''
    异步读 系统调用
    '''
    def __init__(self,f):
        self.f = f

    def handle(self):
        fd = self.f.fileno()
        self.sched.waitforread(self.task,fd)

class WriteWait(SystemCall):
    '''
    异步写 系统调用
    '''
    def _init__(self,f):
        self.f = f

    def handle(self):
        fd = self.f.fileno()
        self.sched.waitforwrite(self.task,fd)