Max number of goroutines

by

If a goroutine is blocked, there is no cost involved other than:

  • memory usage
  • slower garbage-collection

The costs (in terms of memory and average time to actually start executing a goroutine) are:

Go 1.6.2 (April 2016)
  32-bit x86 CPU (A10-7850K 4GHz)
    | Number of goroutines: 100000
    | Per goroutine:
    |   Memory: 4536.84 bytes
    |   Time:   1.634248 µs
  64-bit x86 CPU (A10-7850K 4GHz)
    | Number of goroutines: 100000
    | Per goroutine:
    |   Memory: 4707.92 bytes
    |   Time:   1.842097 µs

Go release.r60.3 (December 2011)
  32-bit x86 CPU (1.6 GHz)
    | Number of goroutines: 100000
    | Per goroutine:
    |   Memory: 4243.45 bytes
    |   Time:   5.815950 µs

On a machine with 4 GB of memory installed, this limits the maximum number of goroutines to slightly less than 1 million.

Source code (no need to read this if you already understand the numbers printed above):

package main

import (
    "flag"
    "fmt"
    "os"
    "runtime"
    "time"
)

var n = flag.Int("n", 1e5, "Number of goroutines to create")

var ch = make(chan byte)
var counter = 0

func f() {
    counter++
    <-ch // Block this goroutine
}

func main() {
    flag.Parse()
    if *n <= 0 {
            fmt.Fprintf(os.Stderr, "invalid number of goroutines")
            os.Exit(1)
    }

    // Limit the number of spare OS threads to just 1
    runtime.GOMAXPROCS(1)

    // Make a copy of MemStats
    var m0 runtime.MemStats
    runtime.ReadMemStats(&m0)

    t0 := time.Now().UnixNano()
    for i := 0; i < *n; i++ {
            go f()
    }
    runtime.Gosched()
    t1 := time.Now().UnixNano()
    runtime.GC()

    // Make a copy of MemStats
    var m1 runtime.MemStats
    runtime.ReadMemStats(&m1)

    if counter != *n {
            fmt.Fprintf(os.Stderr, "failed to begin execution of all goroutines")
            os.Exit(1)
    }

    fmt.Printf("Number of goroutines: %d\n", *n)
    fmt.Printf("Per goroutine:\n")
    fmt.Printf("  Memory: %.2f bytes\n", float64(m1.Sys-m0.Sys)/float64(*n))
    fmt.Printf("  Time:   %f µs\n", float64(t1-t0)/float64(*n)/1e3)
}

More Related Contents:

  1. Sudden Increase in the number of goroutines after upgrade [closed]
  2. No output from goroutine
  3. How to stop a goroutine
  4. cancel a blocking operation in Go
  5. Is it safe to read a function pointer concurrently without a lock?
  6. How to broadcast message using channel
  7. Can I concurrently write different slice elements
  8. Close multiple goroutine if an error occurs in one in go
  9. Prevent the main() function from terminating before goroutines finish in Golang
  10. How to wait for all goroutines to finish without using time.Sleep?
  11. Example for sync.WaitGroup correct?
  12. Why Golang cannot generate json from struct with front lowercase character?
  13. Multiple goroutines listening on one channel
  14. Goroutine does not execute if time.Sleep included
  15. How to collect values from N goroutines executed in a specific order?
  16. Create a generic channel
  17. How to use a module that is outside of “GOPATH” in another module?
  18. How can I convert string to integer in golang
  19. Cyclic dependencies and interfaces
  20. Golang Dependency Management Best Practice
  21. How can I pass a slice as a variadic input?
  22. Does Go provide REPL?
  23. How to compare if two structs, slices or maps are equal?
  24. Stack vs heap allocation of structs in Go, and how they relate to garbage collection
  25. Can I construct a slice of a generic type with different type parameters?
  26. How do I reverse a slice in go?
  27. How to delete an element from a Slice in Golang
  28. How do I compare two functions for pointer equality in the latest Go weekly?
  29. How to start a Go program as a daemon in Ubuntu?
  30. Why a generic can’t be assigned to another even if their type arguments can?

Leave a Comment