distributed_lock

l := &Lock{
	key:        "key1",
	id:         "123456",
	expiration: time.Second * 10,
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
errCh := make(chan error)
go func() {
	err := l.AutoRefresh(ctx, time.Second, time.Second*10, 10)
	if err != nil {
		_ = l.UnLock(ctx)
		errCh <- err
		return
	}
}()

// 第一段
select {
case <-errCh:
	// 自动续约失败，记录日志
default:
	// 执行业务逻辑
}

// 第二段
select {
case <-errCh:
	// 自动续约失败，记录日志
default:
	// 执行业务逻辑
}

// 第三段
select {
case <-errCh:
	// 自动续约失败，记录日志
default:
	// 执行业务逻辑
}
// ...

l := &Lock{
	key:        "key1",
	id:         "123456",
	expiration: time.Second * 10,
}

errCh := make(chan error)
closeCh := make(chan struct{})

go func() {
	maxCounter := 5
	counter := 0
	retryCh := make(chan struct{}, 1)
	defer close(retryCh)
	// 手动定期续约
	ticker := time.NewTicker(time.Second * 8)
	defer ticker.Stop()
	for {
		select {
		case <-ticker.C:
			// 开始续约
			if counter >= maxCounter {
				errCh <- ErrMaxRetryFailed
				return
			}
			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
			err := l.Refresh(ctx)
			cancel()
			if errors.Is(err, context.DeadlineExceeded) {
				retryCh <- struct{}{}
				continue
			}

			if err != nil {
				errCh <- err
				return
			}

			// 续约成功，重置计数器
			counter = 0
		case <-retryCh:
			if counter >= maxCounter {
				errCh <- ErrMaxRetryFailed
				return
			}
			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
			err := l.Refresh(ctx)
			cancel()
			if errors.Is(err, context.DeadlineExceeded) {
				retryCh <- struct{}{}
				continue
			}

			if err != nil {
				errCh <- err
				return
			}

			// 续约成功，重置计数器
			counter = 0
		case <-closeCh:
			// 释放锁
			return
		}
	}
}()

// 第一段
select {
case <-errCh:
	close(closeCh)
	// 自动续约失败，记录日志
default:
	// 执行业务逻辑
}

// 第二段
select {
case <-errCh:
	close(closeCh)
	// 自动续约失败，记录日志
default:
	// 执行业务逻辑
}

// 第三段
select {
case <-errCh:
	close(closeCh)
	// 自动续约失败，记录日志
default:
	// 执行业务逻辑
}