Go语言中优化长随机字符串生成：从io.Reader到高性能实现

import (
    "io"
    "math/rand"
    "time" // 用于初始化随机数种子
)

// randomDataMaker 实现了 io.Reader 接口，用于生成随机字节流
type randomDataMaker struct {
    src rand.Source
}

// Read 方法从随机源生成字节并填充到 p 切片中
func (r *randomDataMaker) Read(p []byte) (n int, err error) {
    for i := range p {
        // 从随机源获取一个64位随机数，并取其低8位作为字节
        p[i] = byte(r.src.Int63() & 0xff)
    }
    return len(p), nil
}

import (
    "fmt"
    "io"
    "io/ioutil" // 用于 ioutil.Discard
    "math/rand"
    "time"
)

func main() {
    // 使用当前时间作为种子初始化随机数源
    randomSrc := randomDataMaker{rand.NewSource(time.Now().UnixNano())}

    // 生成一个2KB的随机字节切片
    length := 2 * 1024 // 2KB
    randomBytes := make([]byte, length)

    // 从 randomSrc 读取 length 字节到 randomBytes
    n, err := io.ReadFull(&randomSrc, randomBytes)
    if err != nil {
        fmt.Printf("Error reading random bytes: %v\n", err)
        return
    }
    fmt.Printf("Generated %d random bytes.\n", n)

    // 示例：将字节转换为十六进制字符串
    hexString := fmt.Sprintf("%x", randomBytes)
    fmt.Printf("Hex string (first 50 chars): %s...\n", hexString[:50])

    // 如果只是想测试生成速度而不存储数据，可以使用 ioutil.Discard
    // _, err = io.CopyN(ioutil.Discard, &randomSrc, int64(length))
    // if err != nil {
    //  fmt.Printf("Error copying to discard: %v\n", err)
    // }
}

import (
    "io"
    "io/ioutil"
    "math/rand"
    "testing"
)

// randomDataMaker 定义与之前相同

func BenchmarkRandomDataMaker(b *testing.B) {
    // 使用固定种子，确保基准测试的可重复性
    randomSrc := randomDataMaker{rand.NewSource(1028890720402726901)}

    // b.N 是基准测试框架确定的迭代次数
    for i := 0; i < b.N; i++ {
        // 每次迭代生成1MB数据，并通过b.SetBytes告知基准测试框架
        // b.SetBytes(1024 * 1024) // 假设每次生成1MB

        // 实际测试中，我们让每次迭代生成的数据量随i变化，以模拟不同大小的生成
        // 这里简化为每次迭代固定生成一定量数据
        length := int64(4 * 1024) // 每次生成4KB
        b.SetBytes(length)

        _, err := io.CopyN(ioutil.Discard, &randomSrc, length)
        if err != nil {
            b.Fatalf("Error copying at %v: %v", i, err)
        }
    }
}

BenchmarkRandomDataMaker       50000        246512 ns/op     202.83 MB/s

// randomDataMaker 的优化 Read 方法
func (r *randomDataMaker) Read(p []byte) (n int, err error) {
    todo := len(p)   // 还需要填充的字节数
    offset := 0      // 当前填充的偏移量

    for {
        val := r.src.Int63() // 获取一个64位随机数
        for i := 0; i < 8; i++ { // 从64位随机数中提取8个字节
            p[offset] = byte(val & 0xff) // 取低8位
            todo--
            if todo == 0 { // 所有字节都已填充
                return len(p), nil
            }
            offset++
            val >>= 8 // 右移8位，准备提取下一个字节
        }
    }
    // 理论上不会执行到这里，因为 todo == 0 会提前返回
    // panic("unreachable") 
}

BenchmarkRandomDataMaker      200000        251148 ns/op     796.34 MB/s

// randomDataMaker 的最终优化 Read 方法
func (r *randomDataMaker) Read(p []byte) (n int, err error) {
    todo := len(p)
    offset := 0

    for {
        val := r.src.Int63()
        for i := 0; i < 8; i++ {
            // 移除冗余的 & 0xff 操作
            p[offset] = byte(val) 
            todo--
            if todo == 0 {
                return len(p), nil
            }
            offset++
            val >>= 8
        }
    }
}

BenchmarkRandomDataMaker      200000        231843 ns/op     862.64 MB/s