Go handles concurrency through goroutines and channels, enabling simple, safe, and scalable concurrent programming. 1. Goroutines are lightweight threads managed by the Go runtime, started with the go keyword, and require minimal resources due to small, growable stacks. 2. Channels facilitate communication between goroutines, preventing race conditions by promoting message passing over shared memory, with unbuffered channels synchronizing sends and receives, and buffered channels allowing limited asynchronous communication. 3. The select statement enables multiplexing across multiple channel operations, supporting non-blocking and responsive designs. 4. Real-world patterns like worker pools use channels to distribute and collect tasks efficiently across concurrent goroutines. 5. The Go scheduler uses an M:N model to map goroutines to OS threads, employing work-stealing and preemption for load balancing and fairness, running by default on GOMAXPROCS CPU cores. Together, these features allow Go to simplify concurrent programming while ensuring efficiency and maintainability.

Go handles concurrency through goroutines and channels, making it simple and efficient to write concurrent programs.

Goroutines: Lightweight Threads

A goroutine is a function that runs concurrently with other functions. It’s like a lightweight thread managed by the Go runtime, not the operating system. You start one with the go keyword:

go doSomething()  // runs concurrently

Compared to OS threads, goroutines are much cheaper:

• Start with a small stack (a few KB) that grows as needed.
• Managed by Go’s runtime scheduler, which multiplexes goroutines onto a small number of OS threads.
• No manual thread management—developers don’t worry about creating or destroying threads.

This allows you to run thousands or even millions of goroutines efficiently.

Channels: Communication Between Goroutines

Goroutines don’t share memory directly. Instead, Go promotes the idea:

"Do not communicate by sharing memory; share memory by communicating."

Channels are the primary way to communicate between goroutines. They are typed conduits through which you can send and receive values:

ch := make(chan int)
go func() {
    ch <- 42  // send
}()
value := <-ch  // receive

Channels help coordinate goroutines and avoid race conditions. There are two types:

• Unbuffered channels: Synchronize sender and receiver (both must be ready).
• Buffered channels: Allow some asynchronous communication (up to buffer size).

Select Statement: Multiplexing Channels

The select statement lets a goroutine wait on multiple channel operations:

select {
case msg1 := <-ch1:
    fmt.Println("Received", msg1)
case ch2 <- "hi":
    fmt.Println("Sent to ch2")
default:
    fmt.Println("No communication")
}

It’s like a switch for channels and is key for building responsive, non-blocking systems.

Real-World Example: Worker Pool

jobs := make(chan int, 100)
results := make(chan int, 100)

// Start workers
for w := 0; w < 3; w   {
    go func() {
        for job := range jobs {
            results <- job * 2
        }
    }()
}

// Send jobs
for j := 0; j < 5; j   {
    jobs <- j
}
close(jobs)

// Collect results
for a := 0; a < 5; a   {
    <-results
}

This pattern is common in concurrent processing—like handling web requests or background tasks.

Under the Hood: The Go Scheduler

Go uses an M:N scheduler that maps M goroutines onto N OS threads. With features like:

• Work-stealing: Balances load across processor cores.
• Preemption: Prevents one goroutine from starving others.
• Runs on GOMAXPROCS (by default, number of CPU cores).

You don’t need to tune this for most apps—it just works well out of the box.

Basically, Go makes concurrency simple, safe, and scalable by combining lightweight goroutines, channel-based communication, and a smart runtime scheduler. It’s not just about doing things in parallel—it’s about writing clean, maintainable concurrent code.

The above is the detailed content of How does Go handle concurrency?. For more information, please follow other related articles on the PHP Chinese website!