Go 中的可变参数列表是否可以在并行任务中安全使用？

func someFunction(args ...int) {
    // 创建可变参数列表的副本
    argsCopy := make([]int, len(args))
    copy(argsCopy, args)

    // 使用可变参数列表的副本进行并行任务
    for _, arg := range argsCopy {
        go func(arg int) {
            // ...
        }(arg)
    }
}

func someFunction(args ...int) {
    // 创建通道
    argsChan := make(chan []int)

    // 创建可变参数列表的副本并发送到通道
    go func() {
        argsCopy := make([]int, len(args))
        copy(argsCopy, args)
        argsChan <- argsCopy
    }()

    // 从通道中接收可变参数列表的副本并进行并行任务
    go func() {
        argsCopy := <-argsChan
        for _, arg := range argsCopy {
            go func(arg int) {
                // ...
            }(arg)
        }
    }()
}

import (
    "fmt"
    "math/big"
    "sync"
)

func isPrime(n *big.Int) bool {
    // ...
}

// 计算一个范围内的素数
func countPrimes(start, end int64) int {
    // 创建通道
    primeChan := make(chan *big.Int)

    var wg sync.WaitGroup
    for i := start; i <= end; i++ {
        // 创建 i 的 big.Int 引用
        num := big.NewInt(i)

        // 将 num 发送到通道
        wg.Add(1)
        go func(num *big.Int) {
            defer wg.Done()

            if isPrime(num) {
                primeChan <- num
            }
        }(num)
    }

    go func() {
        wg.Wait()
        close(primeChan)
    }()

    // 从通道中接收素数
    var count int
    for prime := range primeChan {
        fmt.Println(prime)
        count++
    }

    return count
}