Golang-基於TimeingWheel定時器

來源:互聯網
上載者:User
這是一個建立於 的文章,其中的資訊可能已經有所發展或是發生改變。

設計思路

在linux下實現定時器主要有如下方式

  • 基於鏈表實現定時器
  • 基於排序鏈表實現定時器
  • 基於最小堆實現定時器
  • 基於時間輪實現定時器

在這當中基於時間輪方式實現的定時器時間複雜度最小,效率最高,然而我們可以通過優先隊列實現時間輪定時器。

優先隊列的實現可以使用最大堆和最小堆,因此在隊列中所有的資料都可以定義定序自動排序。我們直接通過隊列中pop函數擷取資料,就是我們按照自訂定序想要的資料。

Golang中實現一個優先隊列異常簡單,在container/head包中已經幫我們封裝了,實現的細節,我們只需要實現特定的介面就可以。

下面是官方提供的例子

// This example demonstrates a priority queue built using the heap interface.// An Item is something we manage in a priority queue.type Item struct {    value    string // The value of the item; arbitrary.    priority int    // The priority of the item in the queue.    // The index is needed by update and is maintained by the heap.Interface methods.    index int // The index of the item in the heap.}// A PriorityQueue implements heap.Interface and holds Items.type PriorityQueue []*Itemfunc (pq PriorityQueue) Len() int { return len(pq) }func (pq PriorityQueue) Less(i, j int) bool {    // We want Pop to give us the highest, not lowest, priority so we use greater than here.    return pq[i].priority > pq[j].priority}func (pq PriorityQueue) Swap(i, j int) {    pq[i], pq[j] = pq[j], pq[i]    pq[i].index = i    pq[j].index = j}func (pq *PriorityQueue) Push(x interface{}) {    n := len(*pq)    item := x.(*Item)    item.index = n    *pq = append(*pq, item)}func (pq *PriorityQueue) Pop() interface{} {    old := *pq    n := len(old)    item := old[n-1]    item.index = -1 // for safety    *pq = old[0 : n-1]    return item}

因為優先隊列底層資料結構是由二叉樹構建的,所以我們可以通過數組來儲存二叉樹上的每一個節點。
改數組需要實現Go預先定義的介面Len,Less,Swap,Push,Popupdate

  • Len 介面定義返回隊列長度
  • Swap 介面定義隊列資料優先順序,比較規則
  • Push 介面定義push資料到隊列中操作
  • Pop 介面定義返回隊列中頂層資料,並且將改資料刪除
  • update 介面定義更新隊列中資料資訊

接下來我們分析 https://github.com/leesper/tao 開源的代碼中TimeingWheel 中的實現細節。

一、設計細節

1. 結構細節

1.1 定時任務結構

type timerType struct {    id         int64    expiration time.Time    interval   time.Duration    timeout    *OnTimeOut    index      int // for container/heap}type OnTimeOut struct {    Callback func(time.Time, WriteCloser)    Ctx      context.Context}

timerType結構是定時任務抽象結構

  • id 定時任務的唯一id,可以這個id尋找在隊列中的定時任務
  • expiration 定時任務的到期時間點,當到這個時間點後,觸發定時任務的執行,在優先隊列中也是通過這個欄位來排序
  • interval 定時任務的觸發頻率,每隔interval時間段觸發一次
  • timeout 這個結構中儲存定時逾時任務,這個任務函數參數必須符合相應的介面類型
  • index 儲存在隊列中的任務所在的下標

1.2 時間輪結構

type TimingWheel struct {    timeOutChan chan *OnTimeOut    timers      timerHeapType    ticker      *time.Ticker    wg          *sync.WaitGroup    addChan     chan *timerType // add timer in loop    cancelChan  chan int64      // cancel timer in loop    sizeChan    chan int        // get size in loop    ctx         context.Context    cancel      context.CancelFunc}
  • timeOutChan 定義一個帶緩衝的chan來儲存,已經觸發的定時任務
  • timers[]*timerType類型的slice,儲存所有定時任務
  • ticker 當每一個ticker到來時,時間輪都會檢查隊列中head元素是否到達逾時時間
  • wg 用於並發控制
  • addChan 通過帶緩衝的chan來向隊列中新增工作
  • cancelChan 定時器停止的chan
  • sizeChan 返回隊列中任務的數量的chan
  • ctxcancel 使用者並發控制

2. 關鍵函數實現

2.1 TimingWheel的主迴圈函數

func (tw *TimingWheel) start() {    for {        select {        case timerID := <-tw.cancelChan:            index := tw.timers.getIndexByID(timerID)            if index >= 0 {                heap.Remove(&tw.timers, index)            }        case tw.sizeChan <- tw.timers.Len():        case <-tw.ctx.Done():            tw.ticker.Stop()            return        case timer := <-tw.addChan:            heap.Push(&tw.timers, timer)        case <-tw.ticker.C:            timers := tw.getExpired()            for _, t := range timers {                tw.TimeOutChannel() <- t.timeout            }            tw.update(timers)        }    }}

首先的start函數,當建立一個TimeingWheel時,通過一個goroutine來執行start,在start中for迴圈和select來監控不同的channel的狀態

  • <-tw.cancelChan 返回要取消的定時任務的id,並且在隊列中刪除
  • tw.sizeChan <- 將定時任務的個數放入這個無緩衝的channel中
  • <-tw.ctx.Done() 當父context執行cancel時,該channel 就會有數值,表示該TimeingWheel 要停止
  • <-tw.addChan 通過帶緩衝的addChan來向隊列中新增工作
  • <-tw.ticker.C ticker定時,當每一個ticker到來時,time包就會向該channel中放入當前Time,當每一個Ticker到來時,TimeingWheel都需要檢查隊列中到到期的任務(tw.getExpired()),通過range來放入TimeOutChannelchannel中, 最後在更新隊列。

2.2 TimingWheel的尋找逾時任務函數

func (tw *TimingWheel) getExpired() []*timerType {    expired := make([]*timerType, 0)    for tw.timers.Len() > 0 {        timer := heap.Pop(&tw.timers).(*timerType)        elapsed := time.Since(timer.expiration).Seconds()        if elapsed > 1.0 {            dylog.Warn(0, "timing_wheel", nil, "elapsed  %d", elapsed)        }        if elapsed > 0.0 {            expired = append(expired, timer)            continue        } else {            heap.Push(&tw.timers, timer)            break        }    }    return expired}

通過for迴圈從隊列中取資料,直到該隊列為空白或者是遇見第一個目前時間比任務開始時間大的任務,appendexpired中。因為優先隊列中是根據expiration來排序的,
所以當取到第一個定時任務未到的任務時,表示該定時任務以後的任務都未到時間。

2.3 TimingWheel的更新隊列函數

func (tw *TimingWheel) update(timers []*timerType) {    if timers != nil {        for _, t := range timers {            if t.isRepeat() { // repeatable timer task                t.expiration = t.expiration.Add(t.interval)                // if task time out for at least 10 seconds, the expiration time needs                // to be updated in case this task executes every time timer wakes up.                if time.Since(t.expiration).Seconds() >= 10.0 {                    t.expiration = time.Now()                }                heap.Push(&tw.timers, t)            }        }    }}

getExpired函數取出隊列中要執行的任務時,當有的定時任務需要不斷執行,所以就需要判斷是否該定時任務需要重新放回優先隊列中。isRepeat是通過判斷任務中interval是否大於 0 判斷,
如果大於0 則,表示永久就生效。

3. TimeingWheel 的用法

防止外部濫用,阻塞定時器協程,架構又一次封裝了timer這個包,名為timer_wapper這個包,它提供了兩種調用方式。

3.1 第一種普通的調用定時任務

func (t *TimerWrapper) AddTimer(when time.Time, interv time.Duration, cb TimerCallback) int64{    return t.TimingWheel.AddTimer(        when,        interv,        serverbase.NewOnTimeOut(t.ctx, func(t time.Time, c serverbase.WriteCloser) {            cb()        }))}
  • AddTimer 添加定時器任務,任務在定時器協程執行
  • when為執行時間
  • interv為執行循環,interv=0隻執行一次
  • cb為回呼函數

3.2 第二種通過任務池調用定時任務

func (t *TimerWrapper) AddTimerInPool(when time.Time, interv time.Duration, cb TimerCallback) int64 {    return t.TimingWheel.AddTimer(        when,        interv,        serverbase.NewOnTimeOut(t.ctx, func(t time.Time, c serverbase.WriteCloser) {            workpool.WorkerPoolInstance().Put(cb)        }))}

參數和上面的參數一樣,只是在第三個參數中使用了任務池,將定時任務放入了任務池中。定時任務的本身執行就是一個put操作。
至於put以後,那就是workers這個包管理的了。在worker包中, 也就是維護了一個任務池,任務池中的任務會有序的執行,方便管理。

相關文章

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.