Which channel type uses the least amount of memory in Go?


I find myself frequently using channels to get things to stop. In these cases the channel is being used solely as a means of signaling, and none of the data is actually used.

For example:

package main

import (

func routine(stopChan chan bool) {
    fmt.Println("goroutine: I've started!")
    fmt.Println("goroutine: Cya'round pal")

func main() {
    fmt.Println("main: Sample program run started")

    stopChan := make(chan bool)

    go routine(stopChan)

    fmt.Println("main: Fired up the goroutine")

    stopChan <- true

    time.Sleep(1 * time.Second)

    fmt.Println("main: Sample program run finished")

// Sample output:
//  main: Sample program run started
//  main: Fired up the goroutine
//  goroutine: I've started!
//  goroutine: Cya'round pal
//  main: Sample program run finished

Run/view it if you please on the golang playground.

My question is:

Which channel type has the lightest memory footprint in Go?

e.g. Is a bool chan going to require any less overhead than an empty struct{} chan?

chan bool

chan byte

chan interface{}

chan struct{}

something else?


Looking at the latest implementation of the channel, it’s not a trivial structure:

type hchan struct {
    qcount   uint           // total data in the queue
    dataqsiz uint           // size of the circular queue
    buf      unsafe.Pointer // points to an array of dataqsiz elements
    elemsize uint16
    closed   uint32
    elemtype *_type // element type
    sendx    uint   // send index
    recvx    uint   // receive index
    recvq    waitq  // list of recv waiters
    sendq    waitq  // list of send waiters
    lock     mutex

Elements of waiter queues are also quite heavy:

type sudog struct {
    g           *g
    selectdone  *uint32
    next        *sudog
    prev        *sudog
    elem        unsafe.Pointer // data element
    releasetime int64
    nrelease    int32  // -1 for acquire
    waitlink    *sudog // g.waiting list

You see, many bytes. Even if any element would be created for an empty channel, this would be negligible.

However, I expect all empty channels to take the same amount of space, regardless of underlying type, so if you intend to only close the channel, there’ll be no difference (an actual element seems to be hold by a pointer). A quick test backs it up:

package main

import (

func main() {
    // channel type
    type xchan chan [64000]byte
    a := make([]xchan, 10000000) // 10 million
    for n := range a {
        a[n] = make(xchan)

I see no difference between chan struct{} and chan [64000]byte, both leads to ~1GB of usage on my 64-bit machine, which makes me believe that overhead of creating a single channel in somewhere around 100 bytes.

In conclusion, it doesn’t really matter. Personally I would use struct{} as it’s the only really empty type (of size 0 indeed), clearly indicating there is no intention of any payload being sent.

Answered By – tomasz

Answer Checked By – Robin (GoLangFix Admin)

Leave a Reply

Your email address will not be published.