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)