Exercises

Channels

  • Modify the program you created in exercise to usechannels, in other words, the function called in the body should now bea goroutine and communication should happen via channels. You should notworry yourself on how the goroutine terminates.

  • There are a few annoying issues left if you resolve question 1 above. One ofthe problems is that the goroutine isn’t neatly cleaned up when main.main()exits. And worse, due to a race condition between the exit of main.main()and main.shower() not all numbers are printed. It should print up until 9,but sometimes it prints only to 8. Adding a second quit-channel you canremedy both issues. Do this.

Answer

  • A possible program is:
  1. package main
  3. import "fmt"
  5. func main() {
  6.     ch := make(chan int)
  7.     go shower(ch)
  8.     for i := 0; i < 10; i++ {
  9.         ch <- i
  10.     }
  11. }
  13. func shower(c chan int) {
  14.     for {
  15.         j := <-c
  16.         fmt.Printf("%d\n", j)
  17.     }
  18. }

We start in the usual way, then at line 6 we create a new channel of ints. In the next line we fire off the function shower with the ch variable as it argument, so that we may communicate with it. Next we start our for-loop (lines 8-10) and in the loop we send (with <-) our number to the function (now a goroutine) shower.

In the function shower we wait (as this blocks) until we receive a number (line 15). Any received number is printed (line 16) and then continue the endless loop started on line 14.

  • An answer is
  1. package main
  3. import "fmt"
  5. func main() {
  6.     ch := make(chan int)
  7.     quit := make(chan bool)
  8.     go shower(ch, quit)
  9.     for i := 0; i < 10; i++ {
  10.         ch <- i
  11.     }
  12.     quit <- false    // or true, does not matter
  13. }
  15. func shower(c chan int, quit chan bool) {
  16.     for {
  17.         select {
  18.         case j := <-c:
  19.             fmt.Printf("%d\n", j)
  20.         case <-quit:
  21.             break
  22.         }
  23.     }
  24. }

On line 20 we read from the quit channel and we discard the value we read. We could have used q := <-quit, but then we would have used the variable only once — which is illegal in Go. Another trick you might have pulled out of your hat may be: _ = <-quit. This is valid in Go, but idomatic Go is the one given on line 20.

Fibonacci II

This is the same exercise as an earlier one inexercise. For completeness the complete question:

The Fibonacci sequence starts as follows: (1, 1, 2, 3, 5, 8, 13, \ldots)Or in mathematical terms:(x1 = 1; x_2 = 1; x_n = x{n-1} + > x_{n-2}\quad\forall n > 2).

Write a function that takes an int value and givesthat many terms of the Fibonacci sequence.

But now the twist: You must use channels.

Answer

The following program calculates the Fibonacci numbers using channels.

  1. package main
  2. import "fmt"
  4. func dup3(in <-chan int) (<-chan int, <-chan int, <-chan int) {
  5.     a, b, c := make(chan int, 2), make(chan int, 2), make(chan int, 2)
  6.     go func() {
  7.         for {
  8.             x := <-in
  9.             a <- x
  10.             b <- x
  11.             c <- x
  12.         }
  13.     }()
  14.     return a, b, c
  15. }
  17. func fib() <-chan int {
  18.     x := make(chan int, 2)
  19.     a, b, out := dup3(x)
  20.     go func() {
  21.         x <- 0
  22.         x <- 1
  23.         <-a
  24.         for {
  25.             x <- <-a+<-b
  26.         }
  27.     }()
  28.     return out
  29. }
  31. func main() {
  32.     x := fib()
  33.     for i := 0; i < 10; i++ {
  34.         fmt.Println(<-x)
  35.     }
  36. }
  38. // See sdh33b.blogspot.com/2009/12/fibonacci-in-go.html