How are channels implemented in Go?

Channels in Go are a means of synchronizing goroutines and passing data between them. They are based on the CSP (Communicating Sequential Processes) paradigm.

Key features:

• Type safety: A channel can only transmit data of a specific type.
• Synchronization: Send (<-chan) and receive (chan<-) operations on a channel block until the corresponding operation is performed by another goroutine.
• Buffering: Channels can be unbuffered (capacity 0) or buffered (capacity > 0).
  • Unbuffered channel: the sender waits until the receiver is ready to accept, and vice versa.
  • Buffered channel: the sender can send data until the buffer is full without waiting for the receiver. The receiver can receive data from the buffer without waiting for the sender.

Internal structure (at the lower level):

A channel is represented by the hchan structure in the Go runtime, which includes:

• qcount: current number of elements in the buffer.
• dataqsiz: size of the buffer (channel capacity).
• buf: pointer to the circular buffer for storing data.
• elemsize: size of one data element in the buffer.
• elemtype: type of data elements.
• sendx: index for the next send position in the buffer.
• recvx: index for the next receive position in the buffer.
• recvq: queue of goroutines waiting to receive.
• sendq: queue of goroutines waiting to send.
• lock: mutex to protect the channel structure from concurrent access by multiple goroutines.

Channel operations:

Send: channel <- value Receive: value := <-channel or value, ok := <-channel

Channel types:

• Unbuffered: make(chan int)
• Buffered: make(chan int, 10) (capacity 10)

Closing a channel:

The function close(ch) is used to signal that no more data will be sent. Sending to a closed channel will cause a panic. Receiving from a closed channel returns the zero value of the type and ok will be false.

// Example of using an unbuffered channel
func main() {
	messages := make(chan string)

	go func() {
		messages <- "hello" // Sending blocks until received
	}()

	msg := <-messages // Receiving blocks until sent
	fmt.Println(msg)
}

// Example of using a buffered channel
func main() {
	messages := make(chan string, 2) // Buffer of 2 elements

	messages <- "hello" // Sending does not block, buffer not full
	messages <- "world" // Sending does not block, buffer not full
	// messages <- "!!!" // This send will block, buffer full

	fmt.Println(<-messages) // Receiving does not block
	fmt.Println(<-messages) // Receiving does not block
}

// Example of closing a channel and checking for closure
func main() {
	jobs := make(chan int, 5)
	done := make(chan bool)

	go func() {
		for {
			j, more := <-jobs
			if more {
				fmt.Println("received job", j)
			} else {
				fmt.Println("received all jobs")
				done <- true
				return
			}
		}
	}()

	for j := 1; j <= 3; j++ {
		jobs <- j
		fmt.Println("sent job", j)
	}
	close(jobs) // Closing the channel

	<-done // Waiting for the receiver goroutine to finish
}