Goroutine 的最小工作量：何时使用协程才划算？

package main

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

func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

// 单线程计算素数
func singleThreadPrimeCount(start, end int) int {
    count := 0
    for i := start; i <= end; i++ {
        if isPrime(i) {
            count++
        }
    }
    return count
}

// 多协程计算素数
func concurrentPrimeCount(start, end int, numGoroutines int) int {
    count := 0
    chunkSize := (end - start + 1) / numGoroutines
    resultChan := make(chan int, numGoroutines)
    var wg sync.WaitGroup

    for i := 0; i < numGoroutines; i++ {
        wg.Add(1)
        chunkStart := start + i*chunkSize
        chunkEnd := chunkStart + chunkSize - 1
        if i == numGoroutines-1 {
            chunkEnd = end
        }

        go func(s, e int) {
            defer wg.Done()
            localCount := 0
            for j := s; j <= e; j++ {
                if isPrime(j) {
                    localCount++
                }
            }
            resultChan <- localCount
        }(chunkStart, chunkEnd)
    }

    wg.Wait()
    close(resultChan)

    for c := range resultChan {
        count += c
    }

    return count
}

func main() {
    start := 2
    end := 100000

    // 单线程
    startTime := time.Now()
    singleThreadCount := singleThreadPrimeCount(start, end)
    singleThreadTime := time.Since(startTime)
    fmt.Printf("Single thread: %d primes found in %s\n", singleThreadCount, singleThreadTime)

    // 多协程
    numGoroutines := runtime.NumCPU() // 使用 CPU 核心数作为协程数量
    startTime = time.Now()
    concurrentCount := concurrentPrimeCount(start, end, numGoroutines)
    concurrentTime := time.Since(startTime)
    fmt.Printf("Concurrent (%d goroutines): %d primes found in %s\n", numGoroutines, concurrentCount, concurrentTime)
}