code: def put(self, taskid, priority=0, exetime=0):
          
          now = time.time()
  
          task = InQueueTask(taskid, priority, exetime)
  
          self.mutex.acquire()
          if taskid in self.priority_queue:
              self.priority_queue.put(task)
          elif taskid in self.time_queue:
              self.time_queue.put(task)
          elif taskid in self.processing and self.processing[taskid].taskid:
              # force update a processing task is not allowed as there are so many
              # problems may happen
              pass
          else:
              if exetime and exetime > now:
                  self.time_queue.put(task)
              else:
                  task.exetime = 0
                  self.priority_queue.put(task)
  
          self.mutex.release()
docs: Put a task into task queue
          
          when use heap sort, if we put tasks(with the same priority and exetime=0) into queue,
          the queue is not a strict FIFO queue, but more like a FILO stack.
          It is very possible that when there are continuous big flow, the speed of select is 
          slower than request, resulting in priority-queue accumulation in short time.
          In this scenario, the tasks more earlier entering the priority-queue will not get 
          processed until the request flow becomes small. 
          
          Thus, we store a global atom self increasing value into task.sequence which represent 
          the task enqueue sequence. When the comparison of exetime and priority have no 
          difference, we compare task.sequence to ensure that the entire queue is ordered.