开源项目timingwheel

ezreal_pan

已于 2024-09-12 18:08:48 修改

阅读量680

点赞数 20

分类专栏： Go 文章标签：开源时间轮 timingwheel

于 2024-09-10 15:16:44 首次发布

本文链接：https://blog.csdn.net/ezreal_pan/article/details/142086593

版权

Go 专栏收录该内容

55 篇文章 0 订阅

订阅专栏

项目地址：RussellLuo/timingwheel: Golang implementation of Hierarchical Timing Wheels. (github.com)

时间轮的原理，我这里就不班门弄斧了，这个项目的作者写了一篇博文，作了详细的说明。层级时间轮的 Golang 实现 | RussellLuo

我这篇文章只是简单的记录一下使用以及部分源码的注解。

源码阅读

// TimingWheel is an implementation of Hierarchical Timing Wheels.
type TimingWheel struct {
	tick      int64 // in milliseconds
	wheelSize int64

	interval    int64 // in milliseconds
	currentTime int64 // in milliseconds
	buckets     []*bucket
	queue       *delayqueue.DelayQueue

	// The higher-level overflow wheel.
	//
	// NOTE: This field may be updated and read concurrently, through Add().
	overflowWheel unsafe.Pointer // type: *TimingWheel

	exitC     chan struct{}
	waitGroup waitGroupWrapper
}

时间轮结构体概念说明：

tick：时间轮一格时间。

wheelSize：一层时间轮有多少格。

interval：一层时间轮的时长。比如，tick设置为s,wheelSize设置为60，那么，interval=60,即表示一层时间为60s。

buckets：任务列表

queue：延时队列，目的是为了优化时间轮空推问题。

overflowWheel：溢出时间轮。比如，第一层时间轮的时间为60s,现在有一个2分钟的任务，超出了第一层时间轮的时间，此时，就会创建高一层的时间轮，就像时钟一样，秒针转一圈推动分针走一格。

// add inserts the timer t into the current timing wheel.
func (tw *TimingWheel) add(t *Timer) bool {
	currentTime := atomic.LoadInt64(&tw.currentTime)
	if t.expiration < currentTime+tw.tick {
		// Already expired
		return false
	} else if t.expiration < currentTime+tw.interval {
		// Put it into its own bucket
		virtualID := t.expiration / tw.tick
		b := tw.buckets[virtualID%tw.wheelSize]
		b.Add(t)

		// Set the bucket expiration time
		if b.SetExpiration(virtualID * tw.tick) {
			// The bucket needs to be enqueued since it was an expired bucket.
			// We only need to enqueue the bucket when its expiration time has changed,
			// i.e. the wheel has advanced and this bucket get reused with a new expiration.
			// Any further calls to set the expiration within the same wheel cycle will
			// pass in the same value and hence return false, thus the bucket with the
			// same expiration will not be enqueued multiple times.
			tw.queue.Offer(b, b.Expiration())
		}

		return true
	} else {
		// Out of the interval. Put it into the overflow wheel
		overflowWheel := atomic.LoadPointer(&tw.overflowWheel)
		if overflowWheel == nil {
			atomic.CompareAndSwapPointer(
				&tw.overflowWheel,
				nil,
				unsafe.Pointer(newTimingWheel(
					tw.interval,
					tw.wheelSize,
					currentTime,
					tw.queue,
				)),
			)
			overflowWheel = atomic.LoadPointer(&tw.overflowWheel)
		}
		return (*TimingWheel)(overflowWheel).add(t)
	}
}

从这一段逻辑，我们可以看出，高一层时间轮的槽数和低层时间轮的槽数是一致的，一格时间则是第一层时间轮一圈的时长。

tw.queue.Offer(b, b.Expiration())，把任务丢到了延时队列中。

b := tw.buckets[virtualID%tw.wheelSize]这一段逻辑没有看懂，不知道是什么目的，看起来就是从桶中获取一个桶，仅此而已。有明白这一段逻辑的，帮忙指点一二。

这个地方的设计逻辑，我搞懂了，这个是为了提升性能，避免，频繁的初始化桶，频繁的初始化桶，还会造成频繁的垃圾回收。

我实际测试了一下，把这个地方改成这样初始化，逻辑是正常的，即验证了我上面的推理。

// Poll starts an infinite loop, in which it continually waits for an element
// to expire and then send the expired element to the channel C.
func (dq *DelayQueue) Poll(exitC chan struct{}, nowF func() int64) {
	for {
		now := nowF()

		dq.mu.Lock()
		item, delta := dq.pq.PeekAndShift(now)
		if item == nil {
			// No items left or at least one item is pending.

			// We must ensure the atomicity of the whole operation, which is
			// composed of the above PeekAndShift and the following StoreInt32,
			// to avoid possible race conditions between Offer and Poll.
			atomic.StoreInt32(&dq.sleeping, 1)
		}
		dq.mu.Unlock()

		if item == nil {
			if delta == 0 {
				// No items left.
				select {
				case <-dq.wakeupC:
					// Wait until a new item is added.
					continue
				case <-exitC:
					goto exit
				}
			} else if delta > 0 {
				// At least one item is pending.
				select {
				case <-dq.wakeupC:
					// A new item with an "earlier" expiration than the current "earliest" one is added.
					continue
				case <-time.After(time.Duration(delta) * time.Millisecond):
					// The current "earliest" item expires.

					// Reset the sleeping state since there's no need to receive from wakeupC.
					if atomic.SwapInt32(&dq.sleeping, 0) == 0 {
						// A caller of Offer() is being blocked on sending to wakeupC,
						// drain wakeupC to unblock the caller.
						<-dq.wakeupC
					}
					continue
				case <-exitC:
					goto exit
				}
			}
		}

		select {
		case dq.C <- item.Value:
			// The expired element has been sent out successfully.
		case <-exitC:
			goto exit
		}
	}

exit:
	// Reset the states
	atomic.StoreInt32(&dq.sleeping, 0)
}

锁定队列并检查任务：
- 使用互斥锁dq.mu保护对队列的访问。
- 调用dq.pq.PeekAndShift(now)方法查看并移除队列中最早到期的任务（如果存在且已到期）。
- item变量存储了到期的任务（如果有的话），delta变量表示当前时间与最早到期任务之间的时间差（以毫秒为单位）。
处理没有任务的情况：
- 如果item为nil，表示队列中没有到期任务。
  - 如果delta为0，表示队列为空，没有任务等待处理。此时，Poll方法会等待dq.wakeupC通道的信号，该信号在新任务被添加到队列时触发。
  - 如果delta大于0，表示队列中有任务，但尚未到期。此时，Poll方法会等待time.After(time.Duration(delta) * time.Millisecond)返回的定时器超时，即等待任务到期，或者等待dq.wakeupC通道的信号（如果在新任务被添加且其到期时间早于当前等待的任务时触发）。
处理到期任务：
- 如果item不为nil，表示有任务到期。
  - 使用select语句尝试将到期任务的值发送到dq.C通道。
  - 如果发送成功，则继续下一次循环。
  - 如果发送失败（因为exitC通道关闭），则跳转到exit标签退出循环。
退出处理：
- 在退出循环时（无论是因为exitC通道关闭还是因为其他原因），重置dq.sleeping状态为0，表示队列不再处于睡眠状态。
避免忙等待：
- 通过使用time.After和select语句等待任务到期或新任务添加的信号，避免了在没有任务时不停地轮询队列，从而有效地解决了空推问题。

使用案例

package main

import (
	"fmt"
	"time"

	"github.com/RussellLuo/timingwheel"
)

func main() {
	tw := timingwheel.NewTimingWheel(time.Millisecond, 20)
	tw.Start()
	defer tw.Stop()
	fmt.Println("TimingWheel start", time.Now())
    
    //1s后的任务
	t := tw.AfterFunc(time.Second, func() {
		fmt.Println("The timer fires", time.Now())
	})
    //1min后的任务
	tw.AfterFunc(time.Minute, func() {
		fmt.Println("The timer fires after 1 Minute", time.Now())
	})

	<-time.After(1 * time.Hour)
	// Stop the timer before it fires
	t.Stop()
}

时间轮实例初始化选择

对于小规模或单一场景的应用：
- 推荐全局初始化一个时间轮实例，以简化系统架构和提高资源利用率。
对于大规模或多场景的应用：
- 可以考虑根据不同的任务类型或需求实例化不同的时间轮实例。例如，将延迟敏感的任务和延迟不敏感的任务分别放在不同的时间轮实例中处理。
动态调整：
- 在实际应用中，可以根据系统负载和任务需求的变化动态地调整时间轮实例的数量和配置。例如，在系统负载较低时合并时间轮实例以减少资源消耗；在系统负载较高时增加时间轮实例以提高并发处理能力。