Golang: cannot send on channel

Question

Why is it not sending on the channel and blocking the execution? How can I make this constellation work so that I can send a signal into MoneyDive() and continue execution?

package main

import (
    "fmt"
)

type Quack func(ch chan bool)

type DagobertDuck struct {
    quack Quack
}

func (self *DagobertDuck) MoneyDive() {
    ch := make(chan bool)
    self.quack(ch)
    b := <-ch
    if b {
        fmt.Println("true")
    } else {
        fmt.Println("false")
    }
}

func mockQuack(ch chan bool) {
    fmt.Println("mockQuack start")
    ch <- true
    fmt.Println("mockQuack done")
}

func main() {
    dd := DagobertDuck{quack: mockQuack}
    dd.MoneyDive()
}

https://play.golang.org/p/1omlb7u6-A

Answer 1

Because you have an unbuffered channel, and you can only send a value on an unbuffered channel without blocking if there is another goroutine which is ready to receive from it.

Since you only have 1 goroutine, it gets blocked. Solution is simple: launch your Quack.quack() method in a new goroutine:

go self.quack(ch)

Then the output (try it on the Go Playground ):

mockQuack start
mockQuack done
true

Another option is to not launch a new goroutine but make a buffered channel, so it can hold some values without any receivers ready to receive from it:

ch := make(chan bool, 1) // buffered channel, buffer for 1 value

This creates a channel which is capable of "storing" one value without any receivers ready to receive it. A second send on the channel would also block, unless the value is received from it first (or a receiver ready to receive a value from it).

Try this buffered channel version on the Go Playground .

Relevant section from the spec: Send statements:

Both the channel and the value expression are evaluated before communication begins. Communication blocks until the send can proceed. A send on an unbuffered channel can proceed if a receiver is ready. A send on a buffered channel can proceed if there is room in the buffer. A send on a closed channel proceeds by causing a run-time panic . A send on a nil channel blocks forever.

Notes:

Based on the received value you print true or false . This can be done with a single line, without the if statement:

fmt.Println(b)

You can even get rid of the b local variable, and print the received value right away:

fmt.Println(<-ch)

Also I assume you used channels because you wanted to play with them, but in your case mockQuack() could simply return the bool value, without the use of channels.