通过不同的跳过方法安排日期时间间隔

Question

我有一个日期时间间隔列表（开始时间和结束时间）。日期时间间隔有一些额外的属性（见 schedule）。 由于排序，我已经有了间隔的上升时间表。 现在我想实现一些方法来处理重叠冲突。 每次应该只运行一个任务。重叠的任务应该被跳过而不是被转移或延迟。

这些调度方法应该是这样的

• FCFS（先到先得）：应该明确
• 优先级等属性的最大值
• 事件的最长持续时间（应该类似于最大值）

所以假设我们有像 Event(Interval, priority): A(0-7, 2), B(5-10, 3), C(8-15,1), D(20-25,0) 这样的事件）。 更高的价值，更高的优先级。

FCFS：A、C、D - 最高优先级：B、D - 最长持续时间：A、C、D

这是我第一次使用 FCFS。我认为这是一种不好的方法 - 对于其他方法也是如此，因为我需要一种反向查找，而不仅仅是最后一个事件。

样本数据：

start1 = datetime.now()
start2 = datetime.now() + timedelta(seconds=40)
start3 = datetime.now() + timedelta(seconds=70)
start4 = datetime.now() + timedelta(seconds=200)

schedule = [{"start": start1,
             "end": start1 + timedelta(seconds=60),
             "name": "Task1",
             "attr": 2},
            {"start": start2,
             "end": start2 + timedelta(seconds=60),
             "name": "Task2",
             "attr": 3},
            {"start": start3,
             "end": start3 + timedelta(seconds=60),
             "name": "Task3",
             "attr": 1},
            {"start": start4,
             "end": start4 + timedelta(seconds=60),
             "name": "Task4",
             "attr": 0}
            ]

助手调用 DateTimeInterval。对于差异我使用了this。

class DateTimeInterval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __sub__(self, other):
        latest_start = max(self.start, other.start)
        earliest_end = min(self.end, other.end)
        return earliest_end - latest_start

FCFS 调度

# now we can order the beginnings
schedule_sorted = sorted(schedule, key=lambda x: (x["start"], x["name"]))

last = None
for job in schedule_sorted:
    interval = DateTimeInterval(job["start"], job["end"])
    # if there is a last entry
    if last:
        interval_last = DateTimeInterval(last["start"], last["end"])
        diff = interval - interval_last
        if diff.total_seconds() > 0:
            logging.warn("%s CONFLICT OVERLAPPING %s!", job["name"], diff)
        else:
            last = job
    else:
        last = job
    logging.info("%s: %s %s", job["name"], job["start"], job["end"])

我可能会破解所有方法，从而产生一些丑陋的代码。

有没有人（处理过实现这种不同的调度要求并且）知道一个很好的方法来做到这一点？

Answer 1

鉴于您对其他方法的解释，我认为您应该改变您的方法。您应该首先按解决标准（FCFS、最长持续时间或优先级）对事件进行排序，而不是按开始时间排序。然后，您应该有一个方法schedule_event()，它可以将一个事件插入到已安排事件的排序列表中，或者删除这些事件。

我们所做的初始排序可确保首先安排所有优先级较高的事件，然后在发生冲突时删除优先级较低的事件。这里有一些骨架代码：

def sort_events(method_name, events):
  ######
  return sorted_events

def schedule_event(event, scheduled_events):
  if not len(scheduled_events):
    scheduled_events.append(event)
    return
  right_index = bisect.bisect(scheduled_events, event)
  left_index = right_index - 1
  if len(scheduled_events) == right_index:
    if event.conflicts(scheduled_events[left_index]):
      return
  else:
    if event.conflicts(scheduled_events[left_index]) or event.conflicts(scheduled_events[right_index]):
      return
  bisect.insort(scheduled_events, event)

def main():
  scheduled_events = []
  sorted_events = sort_events("FCFS", events)
  for event in sorted_events:
    schedule_event(event, scheduled_events)

您应该按排序顺序维护scheduled_events 列表中的事件。按开始时间顺序维护它们。您可以使用bisect module 找出插入时是否有任何冲突。使用bisect.bisect() 查找插入点并检查紧邻左侧和紧邻右侧的冲突。在左边，结束时间应该早于当前事件的开始时间。在右边，开始时间应该在当前事件的结束时间之后。如果没有冲突，使用bisect.insort() 插入，否则，什么也不做。

另外，为了使排序成为可能，您需要定义自己的 Event 类而不是使用字典，并在该类中实现 __lt__() 方法。

class Event:
  def __init__(self, start_time, end_time):
    self.start_time = start_time
    self.end_time = end_time

  def __lt__(self,):
    pass

Answer 2

这应该可以帮助您开始，根据需要调整您的 lambda 函数。我刚刚向您展示了如何做 min 但 max 完全相似。 min 的文档是here

ByFCFS = min(schedule,key=lambda k:k["start"])
ByAttr= min(schedule,key=lambda k:k["attr"])
ByTimeDiff = min(schedule,key=lambda k:k["end"]-k["start"])

>>> ByFCFS
{'start': datetime.datetime(2014, 11, 10, 20, 32, 54, 151000), 'end': datetime.datetime(2014, 11, 10, 20, 33, 54, 151000), 'name': 'Task1', 'attr': 2}
>>> ByAttr
{'start': datetime.datetime(2014, 11, 10, 20, 36, 14, 152000), 'end': datetime.datetime(2014, 11, 10, 20, 37, 14, 152000), 'name': 'Task4', 'attr': 0}
>>> ByTimeDiff
{'start': datetime.datetime(2014, 11, 10, 20, 32, 54, 151000), 'end': datetime.datetime(2014, 11, 10, 20, 33, 54, 151000), 'name': 'Task1', 'attr': 2}
>>> 

请注意，如果有多个最小值（如 ByTimeDiff 示例），这将返回第一条记录。如果需要做max，把min换成max。