Go协程中生成递增唯一Nonce的规范实现方案问询

调用某REST API时要求携带Nonce请求头，该Nonce必须是唯一的时间戳，且每次连续调用的timestamp必须大于前一次。需要启动10个Go协程并发调用该API，但协程执行顺序不可控，导致出现调用时nonce小于前一次的情况，且无法修改API实现。

精简后的问题复现代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    count := 10
    results := make(chan string, count)

    for i := 0; i < 10; i++ {
        go someWork(results)
        // 启用以下代码可得到预期结果，但属于临时方案
        // time.Sleep(time.Millisecond)
    }

    for i := 0; i < count; i++ {
        fmt.Println(<-results)
    }
}

func someWork(done chan string) {
    // 准备HTTP请求，发起请求，将结果发送到done通道
    done <- time.Now().Format("15:04:05.00000")
}

输出可见时间戳并非按先后顺序排列：

13:18:26.98549
13:18:26.98560
13:18:26.98561
13:18:26.98553
13:18:26.98556
13:18:26.98556
13:18:26.98557
13:18:26.98558
13:18:26.98559
13:18:26.98555

不添加sleep代码的情况下，实现预期效果的惯用方法是什么？

Go中解决这类并发场景下的严格递增序列生成问题，最惯用的方式是通过互斥锁或原子操作来保证全局状态的一致性，这里针对时间戳类型的nonce，推荐以下两种实现：

方法一：互斥锁维护纯时间戳nonce #

通过sync.Mutex保护全局的最后使用时间戳，确保每次生成的nonce严格大于前一次，即使并发获取的系统时间相同或乱序，也能通过调整时间戳来满足API要求。

修改后的代码示例：

package main

import (
    "fmt"
    "sync"
    "time"
)

// 全局变量，记录最后一次使用的nonce时间
var lastNonceTime time.Time
// 互斥锁，保护lastNonceTime的读写操作
var nonceMutex sync.Mutex

// generateNonce 生成严格递增的唯一时间戳nonce
func generateNonce() string {
    nonceMutex.Lock()
    defer nonceMutex.Unlock()

    now := time.Now()
    // 如果当前时间不大于上一次的nonce时间，将时间往后推1纳秒
    if now.Before(lastNonceTime) || now.Equal(lastNonceTime) {
        now = lastNonceTime.Add(1)
    }
    // 更新最后一次使用的时间
    lastNonceTime = now
    return now.Format("15:04:05.00000")
}

func main() {
    count := 10
    results := make(chan string, count)

    for i := 0; i < 10; i++ {
        go someWork(results)
    }

    for i := 0; i < count; i++ {
        fmt.Println(<-results)
    }
}

func someWork(done chan string) {
    nonce := generateNonce()
    // 此处替换为实际的HTTP请求逻辑
    done <- nonce
}

方法二：原子操作结合时间戳（可选） #

如果API允许nonce为「时间戳+递增序号」的组合，可使用atomic包维护全局计数器，将时间戳与序号拼接作为nonce，既保证唯一性也能保证递增性，性能更轻量化：

package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

var counter uint64

// generateNonce 生成带序号的递增nonce
func generateNonce() string {
    // 原子递增计数器，保证并发安全
    seq := atomic.AddUint64(&counter, 1)
    // 拼接时间戳与序号
    return fmt.Sprintf("%s-%d", time.Now().Format("15:04:05.00000"), seq)
}

// main和someWork函数同方法一，调用generateNonce即可

说明 #

• 互斥锁方案完全贴合API对「纯时间戳严格递增」的要求，即使系统时间精度有限，也能通过纳秒级调整保证nonce的有效性。
• 原子操作方案性能更高，但需确认API是否接受带序号的nonce格式；若必须使用纯时间戳，优先选择互斥锁方案。

内容的提问来源于stack exchange，提问作者IIvanov