func (b *BackoffBuilder) WithJitter(jitterRate float64) *BackoffBuilder {
	b.layer = append(b.layer, &withJitter{minJitterRate: -jitterRate, maxJitterRate: jitterRate})
	return b
}
WithJitter wrap a base backoff, adds a random jitter value to the original delay using full jitter strategy.
ThejitterRate is used to calculate the lower and upper bound of the ultimate delay.

The lower bound will be ((1 - jitterRate) * originalDelay) and the upper bound will be
((1 + jitterRate) * originalDelay).

For example, if the delay returned by
exponentialBackoff(long, long) is 1000 milliseconds and the provided jitter value is 0.3,
the ultimate backoff delay will be chosen between 1000 * (1 - 0.3) and 1000 * (1 + 0.3)
by randomer. The rate value should be between 0.0 and 1.0.
package backoff
import (
	"fmt"
	"strconv"
	"strings"
	"sync/atomic"
)
type Backoff interface {
	NextDelayMillis(numAttemptsSoFar int) int64
}
type BackoffBuilder struct {
	layer []interface{}
	base  atomic.Value  
	spec  string
}
type withLimit struct {
	limit int
}
type withJitter struct {
	minJitterRate float64
	maxJitterRate float64
}
func NewBackoffBuilder() *BackoffBuilder {
	return &BackoffBuilder{
		layer: make([]interface{}, 0, 4),
	}
}
func (b *BackoffBuilder) BaseBackoffSpec(spec string) *BackoffBuilder {
	b.spec = spec
	return b
}
func (b *BackoffBuilder) BaseBackoff(base Backoff) *BackoffBuilder {
	if base != nil {
		b.base.Store(base)
	}
	return b
}
func (b *BackoffBuilder) WithLimit(limit int) *BackoffBuilder {
	b.layer = append(b.layer, &withLimit{limit})
	return b
}