Go Programming: April 2016

Read Concurrency Parallelism and Goroutines for Beginners before you proceed further.

CodeRef# 1

package main

import "fmt"

func main() {
 
      fmt.Println("A message from main function")
 
      go fmt.Println("A message from goroutine")
  
}

What do you think is the Output of above code?

A message from main function

Play with the Above Code

In most of the cases you would get the above output. But there can be cases where you may get both the messages as output. Here we can conclude that the output of the above code is undefined.

Why didn't it always print the second message from the goroutine?

The func main() here is running in a single OS execution thread. Once the main() code has finished writing "A message from main function" it doesn't wait for the other subroutine (called using the keyword go) to finish its task.

A quick fix solution that can fix this issue is to introduce a delay in the main(). Something like:

CodeRef# 2

package main

import "fmt"
import "time"

func main() {
 
      fmt.Println("A message from main function")
      go fmt.Println("A message from goroutine")
      time.Sleep(1 * time.Second)

Output CodeRef# 2

A message from main function
A message from goroutine

Play with CodeRef# 2

It seems we've achieved what we expected out of that code snippet. Right?

Though we've got the expected result it is a good example of bad programming. Time based synchronization must be avoided as they are inefficient and might lead to ugly bugs. You never know if the process will take 1 second (as introduced in the above example) or more or less than 1 second. Also, the time of execution may differ on different machine configuration. Avoid it!

CodeRef# 3

package main

import "fmt"
import "runtime"

func main() {
 
      fmt.Println("A message from main function")
      go fmt.Println("A message from goroutine")
      runtime.Gosched() 
}

Output CodeRef# 3

A message from main function
A message from goroutine

Play with CodeRef# 3

This looks like a better solution. Here Gosched() has switched the execution context so that the other goroutine can finish its task. Gosched() yields the processor, allowing other goroutines to run.

What are Channels?

Goroutines run concurrently as independent units and hence there must be some mechanism to synchronize the access to shared memory. This is essential to prevent deadlock like scenarios. Go has Channels to sync goroutines.

The Little Go Book by Karl Seguin describes channels as:

You can think Channel as a communication pipe between goroutines which is used to pass data. In other words, A goroutine that has data can pass it to another goroutine via a channel. The result is that, at any point in time, only one goroutine has access to the data.

Remember, a channel can only transmit data-items of one datatype.

Type of Channels

Unbuffered or Synchronous
Buffered or Asynchronous

Declaring & Allocating Memory to Channels

intC := make(chan int) //default capacity = 0

strC := make(chan string, 3) // non-zero capacity

Channel Supports 2 operations SEND and RECEIVE

Channel <- Data // SEND 'data' to a channel

msg :- <- Channel //RECEIVE a message & Assign it to a variable msg

r := make(<-chan bool) // can only read from

w := make(chan<- []os.FileInfo) // can only write to

Note: The left arrow operator <- is used for both sending & receiving data. The arrow head of the operator points in the direction of data flow. The channel SEND & RECEIVE operations are Atomic i.e. they always complete without any interruption.

CodeRef# 4

package main

import (
 "fmt"
 "time"
)

func main() {

 ch := make(chan int)

 go iSend(ch)
 go iReceive(ch)
 time.Sleep(time.Second * 1)
}

func iSend(ch chan int) {
 ch <- 1
 ch <- 3
 ch <- 5
 ch <- 7

}

func iReceive(ch chan int) {
 var info int
 // infinite for loop, executes till 'ch' is empty
 for {
  info = <-ch
  fmt.Printf("%d ", info)
 }
}

Output CodeRef# 4

1 3 5 7

Play with the Code

CodeRef# 5

package main

import "fmt"
import "time"

func main() {
 ch1 := make(chan int)
 go send(ch1)
 go receive(ch1)
 time.Sleep(time.Second * 1)
}

func send(ch chan int) {
 for i := 1; i < 7; i++ {
  ch <- i
 }
}

func receive(ch chan int) {
 for {
  fmt.Println(<-ch)
 }
}

Output CodeRef# 5

Play the code here

CodeRef# 6

package main

import "fmt"
import "time"

func main() {
 ch := make(chan int)
 go sendOdd(ch)
 go sendEven(ch)
 go receive(ch)
 time.Sleep(time.Second * 1)
}

//This func to generate only Odd numbers
func sendOdd(ch chan int) {
 for i := 1; i < 9; i++ {
  if i%2 != 0 {
   ch <- i
  }
 }
}

//This func to generate only Even numbers
func sendEven(ch chan int) {
 for i := 1; i < 9; i++ {
  if i%2 == 0 {
   ch <- i
  }
 }
}

//Recive & Print numbers
func receive(ch chan int) {
 for {
  v := <-ch
  fmt.Println(v)
 }
}

Play with the Code

Output CodeRef# 6

The above code is self explanatory. Play around and you'll soon get the knack of it. Please share your views to improve this article.

References

http://guzalexander.com/2013/12/06/golang-channels-tutorial.html

Go Programming

Wednesday, April 6, 2016

Go Channels for Absolute Beginners