1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

type RateLimiter interface {
	// When gets an item and gets to decide how long that item should wait
    //當一個物件放入的時候，需要回傳延遲多久（可自定義規則，等等會看到）
	When(item interface{}) time.Duration
    
    
	// Forget indicates that an item is finished being retried.  Doesn't matter whether its for perm failing	    
    // or for success, we'll stop tracking it
    //當一個物件完成的時候可以，要忘記曾經延遲過（重新計算）
    Forget(item interface{})
    
    
	// NumRequeues returns back how many failures the item has had
    // 回傳物件已經放入幾次（重試了幾次，白話一點呼叫NumRequeues幾次）
	NumRequeues(item interface{}) int
}

1
2
3
4
5
6
7
8
9

// ItemFastSlowRateLimiter does a quick retry for a certain number of attempts, then a slow retry after that
type ItemFastSlowRateLimiter struct {
	failuresLock sync.Mutex                //鎖，防止資源競爭
	failures     map[interface{}]int       //計算某個物件呼叫了延遲的次數

	maxFastAttempts int                    //最大短嘗試次數
	fastDelay       time.Duration          //短延遲時間
	slowDelay       time.Duration          //長延遲時間
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

//不知道為什麼要設定一個空的變數
var _ RateLimiter = &ItemFastSlowRateLimiter{}

//傳入基礎要最長等待時間，最短等待時間，最大短嘗試次數，以及初始化failures map資料集
func NewItemFastSlowRateLimiter(fastDelay, slowDelay time.Duration, maxFastAttempts int) RateLimiter {
	return &ItemFastSlowRateLimiter{
		failures:        map[interface{}]int{},
		fastDelay:       fastDelay,
		slowDelay:       slowDelay,
		maxFastAttempts: maxFastAttempts,
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func (r *ItemFastSlowRateLimiter) When(item interface{}) time.Duration {
	r.failuresLock.Lock()                    //鎖不做解釋
	defer r.failuresLock.Unlock()            //解鎖不做解釋

	r.failures[item] = r.failures[item] + 1  //放入次數＋1

	if r.failures[item] <= r.maxFastAttempts { //如果放入次數小於短嘗試次數最大值就回傳短延遲時間
		return r.fastDelay
	}

	return r.slowDelay                       //回傳常延遲時間
}

1
2
3
4
5
6

func (r *ItemFastSlowRateLimiter) NumRequeues(item interface{}) int {
	r.failuresLock.Lock()                    //鎖不做解釋
	defer r.failuresLock.Unlock()            //解鎖不做解釋

	return r.failures[item]                  //回傳重試次數
}

1
2
3
4
5
6

func (r *ItemFastSlowRateLimiter) Forget(item interface{}) {
	r.failuresLock.Lock()                    //鎖不做解釋
	defer r.failuresLock.Unlock()            //解鎖不做解釋

	delete(r.failures, item)                 //刪除map裡的物件（重新計算）
}

1
2
3
4
5
6

func NewRateLimitingQueue(rateLimiter RateLimiter) RateLimitingInterface {
	return &rateLimitingType{
		DelayingInterface: NewDelayingQueue(),        //前一小節有提到過delating work queue的newfunction
		rateLimiter:       rateLimiter,               //自行實作的rateLimiter
	}
}

1

NewRateLimitingQueue(NewItemFastSlowRateLimiter(5*time.Millisecond, 3*time.Second, 3)