Learning Golang (some rough notes) - S01E09 - Concurrency (Channels, Goroutines)

func main() {
	tick := time.Tick(100 * time.Millisecond)
	boom := time.After(500 * time.Millisecond)
	for {
		select {
		case <-tick:
			fmt.Println("tick.")
		case <-boom:
			fmt.Println("BOOM!")
			return
		default:
			fmt.Println("    .")
			time.Sleep(50 * time.Millisecond)
		}
	}
}

package main

import (
	"fmt"
	"golang.org/x/tour/tree"
)

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
	fmt.Printf("Walk: %v\n", t.Value)
}

// // Same determines whether the trees
// // t1 and t2 contain the same values.
// func Same(t1, t2 *tree.Tree) bool

func main() {
	c := make(chan int)
	go Walk(tree.New(1), c)
	for i := 0; i < 10; i++ {
		select {
		case <-c:
			fmt.Println(c)
		}
	}
}

Walk: 10
fatal error: all goroutines are asleep - deadlock!

func main() {
	c := make(chan int)
	go Walk(tree.New(1), c)
	for i := 0; i < 10; i++ {
		select {
		case <-c:
			fmt.Println(c)
		default:
			fmt.Printf("default: %v\n", i)
		}
	}
}

default: 0
default: 1
default: 2
default: 3
default: 4
default: 5
default: 6
default: 7
default: 8
default: 9
Walk: 10

case <-c:
	fmt.Printf("Tree value: %v\n", c)

function Walk: 10
Tree value: 0xc0000200c0

case x := <-c:
	fmt.Printf("Tree value: %v\n", x)

function Walk: 10
Tree value: 10

type Tree struct {
    Left  *Tree
    Value int
    Right *Tree
}

func Walk(t *tree.Tree, ch chan int) {
	ch <- t.Value
	if t.Left != nil {
		go Walk(t.Left, ch)
	}
	if t.Right != nil {
		go Walk(t.Right, ch)
	}
}

Tree value: 10
Tree value: 5
Tree value: 7
Tree value: 9
Tree value: 3
Tree value: 6
Tree value: 4
Tree value: 1
Tree value: 2
Tree value: 8

func Same(t1, t2 *tree.Tree) bool {
	// Create a channel into which each tree's values will be written
	c1 := make(chan int)
	c2 := make(chan int)
	// Declare two variables that will be used to collate the
	// channel values
	var x1 []int
	var x2 []int
	// Walk the two trees
	go Walk(t1, c1)
	go Walk(t2, c2)
	// Receive the values
	for i := 0; i < 10; i++ {
		x := <-c1
		x1 = append(x1, x)
	}
	for i := 0; i < 10; i++ {
		x := <-c2
		x2 = append(x2, x)
	}

	fmt.Printf("\nx1 is %v\n", x1)
	fmt.Printf("\nx2 is %v\n", x2)

	// Not even doing the comparison yet
	return false

x1 is [7 4 2 1 3 5 6 9 8 10]

x2 is [8 7 5 3 2 1 4 6 10 9]

func Walk(t *tree.Tree, ch chan int) {
	// Synchronously call the recursive function for the current node
    WalkRecursive(t, ch)
	// Once we've processed every node, close the channel to indicate 
	// that we've finished (and thus allow range to be used)
    close(ch)
}

func WalkRecursive(t *tree.Tree, ch chan int) {
	// If this node isn't null
    if t != nil {
		// Keep traversing, down the left-hand side of the tree
        WalkRecursive(t.Left, ch)
		// Bearing in mind that this is a recursive function
		// we will eventually hit the bottom of the left-hand side
		// of the tree, and thus the above call to WalkRecursive will 
		// return and we can put our node's value onto the channel
        ch <- t.Value
		// Navigate any right-hand nodes too
        WalkRecursive(t.Right, ch)
    }
}

func main() {
	c := make(chan int)
	go Walk(tree.New(1), c)
	fmt.Printf("Tree value: ")
	for i := 0; i < 10; i++ {
		x := <-c
		fmt.Printf("%v ", x)
	}

Tree value: 1 2 3 4 5 6 7 8 9 10 

func Same(t1, t2 *tree.Tree) bool {
	// Each tree is read into separate channels
    ch1, ch2 := make(chan int), make(chan int)
	// Asynchronously walk both trees into their
	// respective channels
    go Walk(t1, ch1)
    go Walk(t2, ch2)
	// Loop
    for {
		// Read the next value from each channel
		// Note that these will block (what happens if the trees are different sizes and ch2 is empty?)
        n1, ok1 := <- ch1
        n2, ok2 := <- ch2
		// If the values don't match, or one channel is closed whilst the 
		// other is not then we know they are not the same
        if ok1 != ok2 || n1 != n2 {
			// Exit and return false
        	return false
        }
		// If the first channel has closed then break out of the loop
		// I guess you could just `return true` here directly? 
        if !ok1 {
        	break;
        }
    }
    return true
}

func main() {
	fmt.Printf("\n-> Comparing trees with the same contents : %v", Same(tree.New(1), tree.New(1)))
	fmt.Printf("\n-> Comparing trees with different contents: %v", Same(tree.New(1), tree.New(2)))
}

-> Comparing trees with the same contents : true
-> Comparing trees with different contents: false