Channels in Go - range and select

Other topics in this series - Table of Contents

Channels and range

This is the second part of tutorial on channels in Go. If you haven’t yet gone through the first part, Channels in Go, please go through it now.

Receivers of data have a problem of knowing when to stop waiting for data. Is there more to come or is it all done? Should we wait or should we move on? One option is to constantly poll the source and check if the channel is closed or not, but that isn’t very efficient. Go provides the range keyword which when used with a channel will wait on the channel until it is closed.

Full code

package main                                                                                             
import (
    "fmt"
    "time"
    "strconv"
)

func makeCakeAndSend(cs chan string, count int) {
    for i := 1; i <= count; i++ {
        cakeName := "Strawberry Cake " + strconv.Itoa(i)
        cs <- cakeName //send a strawberry cake
    }   
}

func receiveCakeAndPack(cs chan string) {
    for s := range cs {
        fmt.Println("Packing received cake: ", s)
    }
}

func main() {
    cs := make(chan string)
    go makeCakeAndSend(cs, 5)
    go receiveCakeAndPack(cs)

    //sleep for a while so that the program doesn’t exit immediately
    time.Sleep(3 * 1e9)
}

Packing received cake: Strawberry Cake 1
Packing received cake: Strawberry Cake 2
Packing received cake: Strawberry Cake 3
Packing received cake: Strawberry Cake 4
Packing received cake: Strawberry Cake 5

To the cake maker we have indicated that we want 5 cakes made, but the receiver does not know that. In earlier versions of the code, we hard coded the exact number for the receipt also. But by using the range keyword on the channel in the code above, we avoid that need - now when the channel is closed, the for loop automatically stops.

Channels and select

The select keyword when used in conjunction with many channels works like a are-you-ready polling mechanism across different channels. The case blocks within it can be for sending or receiving - when either a send or a receive is initiated with the <- operator, then that channel is ready. There can also be a default case block, which is always ready. The algorithm with which the select keyword works on blocks can be approximated to this:
* check each of the case blocks
* if any one of them is sending or receiving, execute the code block corresponding to it
* if more than one is sending or receiving, randomly pick any of them and execute its code block
* if none of them are ready, wait
* if there is a default block, and none of the other case blocks are ready, then execute the default block (I’m not very sure about this, but from coding experiments, it appears that default gets last priority)

In the program below, we have extended our cake making factory to simulate the production of more than 1 flavor of cake - both strawberry and chocolate now! But the packing mechanism is the same. Also it takes more time to make a cake than pack one, which means that we can gain efficiency from packing different types of cake with the same packing machine. Since cakes come from different channels and the packer cannot know the exact moment when a cake is placed on either or many channels, it can use the select statement and wait across all of them - as soon as one of the channels is receiving a cake/data, it will implement its code block.

Note also how we have used multiple return values case cakeName, strbry_ok := <-strbry_cs:. The second return value is a bool which when false indicates that the channel is closed. If it is true, it indicates that a value was transferred. I have used it to check whether I can stop waiting for all cakes.

Full code

package main

import (
    "fmt"
    "time"
    "strconv"
)

func makeCakeAndSend(cs chan string, flavor string, count int) {
    for i := 1; i <= count; i++ {
        cakeName := flavor + " Cake " + strconv.Itoa(i)
        cs <- cakeName //send a strawberry cake
    }   
    close(cs)
}

func receiveCakeAndPack(strbry_cs chan string, choco_cs chan string) {
    strbry_closed, choco_closed := false, false

    for {
        //if both channels are closed then we can stop
        if (strbry_closed && choco_closed) { return }
        fmt.Println("Waiting for a new cake ...")
        select {
        case cakeName, strbry_ok := <-strbry_cs:
            if (!strbry_ok) {
                strbry_closed = true
                fmt.Println(" ... Strawberry channel closed!")
            } else {
                fmt.Println("Received from Strawberry channel.  Now packing", cakeName)
            }   
        case cakeName, choco_ok := <-choco_cs:
            if (!choco_ok) {
                choco_closed = true
                fmt.Println(" ... Chocolate channel closed!")
            } else {
                fmt.Println("Received from Chocolate channel.  Now packing", cakeName)
            }   
        }   
    }   
}

func main() {
    strbry_cs := make(chan string)
    choco_cs := make(chan string)

    //two cake makers
    go makeCakeAndSend(choco_cs, "Chocolate", 3)  //make 3 chocolate cakes and send
    go makeCakeAndSend(strbry_cs, "Strawberry", 3)  //make 3 strawberry cakes and send

    //one cake receiver and packer
    go receiveCakeAndPack(strbry_cs, choco_cs)  //pack all cakes received on these cake channels

    //sleep for a while so that the program doesn’t exit immediately
    time.Sleep(2 * 1e9)
}

Waiting for a new cake ...
Received from Strawberry channel. Now packing Strawberry Cake 1
Waiting for a new cake ...
Received from Chocolate channel. Now packing Chocolate Cake 1
Waiting for a new cake ...
Received from Chocolate channel. Now packing Chocolate Cake 2
Waiting for a new cake ...
Received from Strawberry channel. Now packing Strawberry Cake 2
Waiting for a new cake ...
Received from Strawberry channel. Now packing Strawberry Cake 3
Waiting for a new cake ...
Received from Chocolate channel. Now packing Chocolate Cake 3
Waiting for a new cake ...
... Strawberry channel closed!
Waiting for a new cake ...
... Chocolate channel closed!

Other topics in this series - Table of Contents