定時任務
定時任務是celery的一個重要功能，本節會對celery的定時任務進行分析。
根據之前分析可知，在celery啟動的過程中，會創建并啟動Beat組件，而celery的任務調度服務就在Beat組件啟動的過程中被啟動了。
首先，我們來看celery.apps.beat.Beat類的部分聲明

class Beat(object):
    """Beat as a service."""

    # 調度服務
    Service = beat.Service
    app = None

該類中的屬性Service即為調度服務，默認指向celery.beat.Service類，我們將目光轉向該類的聲明

class Service(object):
    """Celery periodic task service."""

    # 調度器
    scheduler_cls = PersistentScheduler

可以看到，該類中有一屬性為調度器，指向了celery.beat.PersistentScheduler類，從這里我們可以分析得出，服務的調度類為PersistentScheduler類，該類又繼承自同一文件中聲明的Scheduler類。繼承關系如下圖所示：

image.png

在創建了celery.beat.Service實例后，會調用該實例的start()方法，在改方法中，定義如下

def start(self, embedded_process=False):
        info('beat: Starting...')
        debug('beat: Ticking with max interval->%s',
              humanize_seconds(self.scheduler.max_interval))

        signals.beat_init.send(sender=self)
        if embedded_process:
            signals.beat_embedded_init.send(sender=self)
            platforms.set_process_title('celery beat')

        try:
            while not self._is_shutdown.is_set():
                interval = self.scheduler.tick()
                if interval and interval > 0.0:
                    debug('beat: Waking up %s.',
                          humanize_seconds(interval, prefix='in '))
                    time.sleep(interval)
                    if self.scheduler.should_sync():
                        self.scheduler._do_sync()
        except (KeyboardInterrupt, SystemExit):
            self._is_shutdown.set()
        finally:
            self.sync()

其中可以看到，該方法創建了一個事件循環，其中啟動了調度服務，而且我們可以看到在循環中有scheduler相關的方法調用，接下來，我們尋找相關的聲明，來看看scheduler是怎樣初始化的

def get_scheduler(self, lazy=False,
                      extension_namespace='celery.beat_schedulers'):
        filename = self.schedule_filename
        aliases = dict(
            load_extension_class_names(extension_namespace) or {})
        return symbol_by_name(self.scheduler_cls, aliases=aliases)(
            app=self.app,
            schedule_filename=filename,
            max_interval=self.max_interval,
            lazy=lazy,
        )

    @cached_property
    def scheduler(self):
        return self.get_scheduler()

這里可以看到，celery.beat.Service實例中，并沒有聲明scheduler屬性，而是聲明了一個方法并且用一個cached_property裝飾器對其進行了修飾。該裝飾器的作用是將方法調用的結果緩存起來，以便下次可以直接使用。

而第一次調用該方法時，將會調用get_scheduler創建一個self.scheduler_cls類型的實例，一般地，該實例的類型為PersistentScheduler。在使用中，可以將scheduler方法以調用屬性的方法使用，可以理解為以單例模式使用scheduler。

回到celery.beat.Service.start()方法，我們可以看到該方法中首先調用了self.scheduler.tick()獲取間隔時間，之后會sleep該時間間隔后，再通過self.scheduler.should_sync()判斷是否需要進行同步，若需要則調用self.scheduler._do_sync()進行同步。

接下來，我們來分析celery.beat.Scheduler.tick()是怎樣實現任務調度的，同樣地，首先來看該方法的聲明

def tick(self, event_t=event_t, min=min, heappop=heapq.heappop,
             heappush=heapq.heappush):
        """Run a tick - one iteration of the scheduler.

        Executes one due task per call.

        Returns:
            float: preferred delay in seconds for next call.
        """
        adjust = self.adjust
        max_interval = self.max_interval

        if (self._heap is None or
                not self.schedules_equal(self.old_schedulers, self.schedule)):
            self.old_schedulers = copy.copy(self.schedule)
            self.populate_heap()

        H = self._heap # 使用小根堆作為任務隊列

        if not H:
            return max_interval

        event = H[0]
        entry = event[2]
        is_due, next_time_to_run = self.is_due(entry)
        if is_due:
            verify = heappop(H)
            if verify is event:
                next_entry = self.reserve(entry)
                self.apply_entry(entry, producer=self.producer)
                heappush(H, event_t(self._when(next_entry, next_time_to_run),
                                    event[1], next_entry))
                return 0
            else:
                heappush(H, verify)
                return min(verify[0], max_interval)
        return min(adjust(next_time_to_run) or max_interval, max_interval)

我們可以看到，這里使用了一個heap存儲任務列表，每次從堆頂取出一個事件，若該事件通過校驗，則對該事件進行調度并將下次執行的事件放入堆中，否則只將該事件放入堆中，最后返回下次的任務執行時間與最大間隔時間中的最小值

接下來分析celery.beat.Scheduler.should_sync()方法

def should_sync(self):
        return (
            (not self._last_sync or
               (monotonic() - self._last_sync) > self.sync_every) or
            (self.sync_every_tasks and
                self._tasks_since_sync >= self.sync_every_tasks)
        )

可以看到，該方法的實現比較簡單，總結一下就是若上次同步的時間差大于最大時間差最大限制，則返回True 最后，

我們來分析celery.beat.Scheduler._do_sync()方法

class Scheduler(object):
    def _do_sync(self):
        try:
            debug('beat: Synchronizing schedule...')
            self.sync()
        finally:
            self._last_sync = monotonic()
            self._tasks_since_sync = 0

    def sync(self):
        pass

class PersistentScheduler(Scheduler):
    def sync(self):
        if self._store is not None:
            self._store.sync()

這里可以看到，該方法中調用了sync()方法，而在PersistentScheduler中重寫了sync()方法，這里是使用了Python的shelve模塊創建了一個存儲的文件，并將內存中的數據存儲至該文件中（實際上就是進行了一次持久化操作）。

image.png

簡單總結一下，celery的任務調度的核心是使用一個最小堆實現優先級隊列，并且每隔一段時間將調度的任務隊列持久化至文件中，以防進程中斷造成任務丟失的問題。

參考資料

Python內置函數property()使用實例
紅黑樹 vs 最小堆
shelve -- 用來持久化任意的Python對象