Go 言語の同時実行モデルのパフォーマンスはどのくらいですか?

import threading

NUM_THREADS = 1000
NUM_STEPS = 1000000

def calculate_pi(start, end, step):
    pi = 0
    for i in range(start, end):
        x = (i + 0.5) * step
        pi += 4.0 / (1.0 + x * x)
    return pi

threads = []

for i in range(NUM_THREADS):
    start = int(i * NUM_STEPS / NUM_THREADS)
    end = int((i+1) * NUM_STEPS / NUM_THREADS)
    thread = threading.Thread(target=calculate_pi, args=(start, end, 1/NUM_STEPS))
    threads.append(thread)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

package main

import (
    "sync"
)

const (
    numThreads = 1000
    numSteps = 1000000
)

func calculatePi(start int, end int, step float64, wg *sync.WaitGroup, ch chan float64) {
    pi := 0.0
    for i := start; i < end; i++ {
        x := (float64(i) + 0.5) * step
        pi += 4.0 / (1.0 + x * x)
    }
    ch <- pi
    wg.Done()
}

func main() {
    wg := &sync.WaitGroup{}
    ch := make(chan float64, numThreads)

    for i := 0; i < numThreads; i++ {
        start := int(float64(i) * float64(numSteps) / float64(numThreads))
        end := int(float64(i+1) * float64(numSteps) / float64(numThreads))
        wg.Add(1)
        go calculatePi(start, end, 1.0/float64(numSteps), wg, ch)
    }

    wg.Wait()
    close(ch)

    pi := 0.0
    for result := range ch {
        pi += result
    }

    pi *= 1.0 / float64(numSteps)

    fmt.Println(pi)
}