Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Goroutines are lightweight units of concurrent work managed by Go’s runtime; OS threads are execution resources managed by the operating system. Go schedules many goroutines across worker threads rather than assigning each goroutine its own thread. The number of goroutines a program can have is therefore not the number of tasks executing Go code at the same instant: that parallel execution is limited by GOMAXPROCS and the machine’s available CPU capacity.
Goroutines and OS threads are different things
A goroutine is a function running concurrently with other goroutines in a Go program’s address space. An OS thread is a path of execution that the operating system schedules on a processor. The Go runtime manages goroutines and multiplexes them over OS threads, so there is no one-to-one relationship between the two.
| Aspect | Goroutine | OS thread |
|---|---|---|
| Managed by | Go runtime | Operating system |
| Role | A unit of concurrent work, such as a function launched with go |
An execution resource on which code can run |
| Scheduling | Scheduled by Go onto worker threads | Scheduled by the operating system onto available processors |
| Relationship | Many goroutines can share worker threads over time | A thread can run different goroutines at different times |
Go documentation describes goroutines as lightweight, but that does not mean they are free or that any particular program can create an unlimited number efficiently. The useful distinction is that starting concurrent work does not require creating a dedicated OS thread for every task. The official Go FAQ explains why Go uses goroutines instead of requiring programmers to manage a thread for each independently executing function.
How Go schedules goroutines on threads
The runtime’s scheduler distributes runnable goroutines across worker threads. Its common mental model uses three labels: G for a goroutine, M for a worker thread, and P for the resources required to execute Go code. A goroutine runs when the runtime has paired it with an M and a P.
#1 Best Overall
- The world’s fastest gaming processor, built on AMD ‘Zen5’ technology and Next Gen 3D V-Cache.
- 8 cores and 16 threads, delivering +~16% IPC uplift and great power efficiency
- 96MB L3 cache with better thermal performance vs. previous gen and allowing higher clock speeds, up to 5.2GHz
- Drop-in ready for proven Socket AM5 infrastructure
- Cooler not included
- G: the goroutine, or unit of work.
- M: an OS thread used by the Go runtime as a worker.
- P: the runtime resource needed for an M to execute Go code.
An M that enters a system call can release its P, allowing another M to use that P to execute Go code. This arrangement helps Go keep other work moving when a thread is blocked. It does not mean all blocking operations behave identically, nor does it make synchronization unnecessary. Shared state still needs to be coordinated correctly. The runtime source describes the scheduler and its G/M/P model at runtime/proc.go.
Concurrency is not the same as parallelism
Concurrency is how a program structures work so multiple tasks can make progress independently. Parallelism means executing multiple tasks at the same time. A Go program can have many concurrent goroutines even when only a smaller number are executing Go code simultaneously.
Rank #2
- Can deliver fast 100 plus FPS performance in the world's most popular games, discrete graphics card required
- 6 Cores and 12 processing threads, bundled with the AMD Wraith Stealth cooler
- 4.2 GHz Max Boost, unlocked for overclocking, 19 MB cache, DDR4-3200 support
- For the advanced Socket AM4 platform
For example, a server may use separate goroutines to handle many requests. Some may be waiting for network input while others are running. Organizing each request as concurrent work does not imply that every request is using a CPU core at once. As Effective Go emphasizes, concurrency and parallelism are distinct.
What GOMAXPROCS limits
GOMAXPROCS sets the maximum number of CPUs that can execute Go code simultaneously. It is a limit on concurrent Go-code execution, not a ceiling on the total number of OS threads in the process. The runtime may have more threads, including threads blocked in system calls.
Rank #3
- AMD Ryzen 9 9950X3D Gaming and Content Creation Processor
- Max. Boost Clock : Up to 5.7 GHz; Base Clock: 4.3 GHz
- Form Factor: Desktops , Boxed Processor
- Architecture: Zen 5; Former Codename: Granite Ridge AM5
With GOMAXPROCS=4, at most four goroutines can execute Go code at the same time. That does not promise that a program will keep four CPUs busy: actual utilization depends on whether the program has runnable work and what that work is doing. The runtime package documentation describes the setting and its default.
How Go chooses the default—and why version matters
The default is not simply “the number of cores in the computer” in every current environment. Runtime documentation says Go bases its default on available logical CPUs, process CPU affinity, and, on Linux, average CPU throughput permitted by a cgroup quota. A logical CPU is not necessarily the same as a physical CPU core.
Rank #4
- Pure gaming performance with smooth 100+ FPS in the world's most popular games
- 6 Cores and 12 processing threads, based on AMD "Zen 5" architecture
- 5.4 GHz Max Boost, unlocked for overclocking, 38 MB cache, DDR5-5600 support
- For the state-of-the-art Socket AM5 platform, can support PCIe 5.0 on select motherboards
- Cooler not included
Go 1.25 added awareness of Linux cgroup CPU-bandwidth limits to the default GOMAXPROCS calculation, along with periodic updates when relevant CPU availability or limits change. Setting GOMAXPROCS manually disables those automatic behaviors. These changes are documented in the Go 1.25 release notes and the Go Blog’s Container-aware GOMAXPROCS article, published August 20, 2025. The effective default therefore depends on Go version and runtime environment; check the documentation for the version you deploy rather than assuming a fixed value.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.How many goroutines can run at once?
There is no single number of goroutines that can exist or be runnable for every Go program. The relevant limit for simultaneous Go-code execution is GOMAXPROCS: at most that many goroutines execute Go code at once. Other goroutines can be waiting, blocked, or ready to run, and the runtime can use more OS threads than the GOMAXPROCS value.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsBest Value
- Processor provides dependable and fast execution of tasks with maximum efficiency.Graphics Frequency : 2200 MHZ.Number of CPU Cores : 8. Maximum Operating Temperature (Tjmax) : 89°C.
- Ryzen 7 product line processor for better usability and increased efficiency
- 5 nm process technology for reliable performance with maximum productivity
- Octa-core (8 Core) processor core allows multitasking with great reliability and fast processing speed
- 8 MB L2 plus 96 MB L3 cache memory provides excellent hit rate in short access time enabling improved system performance
The Go Blog illustrates the distinction with GOMAXPROCS=8 and 1,000 runnable goroutines: eight can execute Go code at once. That is an explanatory example, not a benchmark or a claim that a program will fully use eight CPUs. See the example in Container-aware GOMAXPROCS.
Why use goroutines instead of one thread per task?
Goroutines let Go programs express independent work without making application code create and manage an OS thread for every task. The runtime can schedule those tasks across worker threads and keep other work progressing when some goroutines wait, for example, on I/O. This is especially useful when a program has many concurrent activities but only a limited amount of CPU work can happen in parallel.
The trade-off is not that threads disappear: the runtime relies on OS threads to execute code, and blocking system calls or interactions with foreign libraries may have behavior that requires attention. Nor does a goroutine remove the need to design correct coordination between tasks. It changes the unit the program works with and delegates much of the scheduling to Go’s runtime.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Free tools Windows power users keep installed
One-click scans. No signup required.
