Are Go Channels Passed by Reference?

Are Channels Passed by Reference?

Go language introduces channels for concurrency, which are like pipes for communication between goroutines. The behavior of channels has raised questions regarding their passing mechanism.

Consider the Go tour example for channels:

package main

import "fmt"

func sum(a []int, c chan int) {
    sum := 0
    for _, v := range a {
        sum += v
    }
    c <- sum // send sum to c
}

func main() {
    a := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(a[:len(a)/2], c)
    go sum(a[len(a)/2:], c)
    x, y := <-c, <-c // receive from c

    fmt.Println(x, y, x+y)
}

In this example, a channel c is shared between two goroutines, each executing the sum function. Modifications to the channel in the function are observed in the main routine. This behavior suggests channels are passed by reference.

The technical reason behind this behavior lies in the way channels are initialized and used. The make function allocates memory on the heap, effectively creating a pointer, although it is not exposed to the programmer. This pointer is assigned to the channel variable, allowing it to be treated as a reference type.

The Go language specification confirms this behavior:

"The built-in function make takes a type T, which must be a slice, map or channel type, optionally followed by a type-specific list of expressions. It returns a value of type T (not *T)."

Therefore, channels in Go are implicitly passed by reference. This enables efficient communication between goroutines and simplifies synchronization mechanisms.

The above is the detailed content of Are Go Channels Passed by Reference?. For more information, please follow other related articles on the PHP Chinese website!