Gain insights into implementing concurrency in Go, explore common patterns, and learn to write efficient, practical applications leveraging Go's outstanding support for concurrency.

Go.tar.gz

DataRaceBuilder

temp

Mastering concurrency can make you a much more in-demand developer on the job market. It's becoming an increasingly important concept in modern programming as multi-core devices become more and more prevalent.

The good news is that Go has some outstanding support for concurrency out of the box that makes implementation a breeze. In fact, concurrency in Go is easier to implement and faster than in any other major language.

In this course, you'll start off with a general introduction to concurrency and build up to more advanced concepts and implementation in Go. You'll also have a chance to go through some common patterns that will make your life easier and your code more efficient. By the time you're done, you'll be able to make use of Go to write efficient, practical applications that use concurrency.

Mastering Concurrency in Go

> The select statement blocks the code and waits for multiple channel opera­tions simul­taneously. 

# Syntax
The syntax for the `select` statement is as follows:


select {   
  case channel operation:     
    statement(s);     
       . //more cases
       .
       .      
  default : //Optional
    statement(s); 
}

# Example 
Let's try to understand the usage of a select statement with a simple example consisting of two channels which are communicating using send/receive operations:

package main

import (
	"fmt"
	"time"
)

func main() {
	channel1 := make(chan string)
	channel2 := make(chan string)

	go func() {
		for i := 0; i < 5; i++ {
			channel1 <- "I'll print every 100ms"
			time.Sleep(time.Millisecond * 100)
			
		}
	}()

	go func() {
		for i := 0; i < 5; i++ {
			channel2 <- "I'll print every 1s"
			time.Sleep(time.Second * 1)
			
		}
	}()

	for i := 0; i < 5; i++ {
		
		fmt.Println(<-channel1)
		fmt.Println(<-channel2)
		
	}
}

In the code above, we have two goroutines, each of which is sending messages on each of the two channels. 

The first goroutine sends a message `I'll print every 100ms` and then waits for 100ms before sending the message again in the next iteration. 
```
go func() {
	for i := 0; i < 5; i++ {
			channel1 <- "I'll print every 100ms"
			time.Sleep(time.Millisecond * 100)
			
		}
	}()
```

On the other hand, the second goroutine functions similarly and sends a message `I'll print every 1s` in each of the five iterations with a delay of 1s. 
```
go func() {
		for i := 0; i < 5; i++ {
			channel2 <- "I'll print every 1s"
			time.Sleep(time.Second * 1)
			
		}
	}()
```


The interesting thing happens in this part of the code: 
```
for i := 0; i < 5; i++ {
		
		fmt.Println(<-channel1)
		fmt.Println(<-channel2)
		
	}
```
`fmt.Println(<-channel1)` receives and prints the message `I'll print every 100ms` and the program moves to `fmt.Println(<-channel2)`. After receiving and printing the message from the second goroutine, we get done with our first iteration. However, in the second iteration, after `channel1` receives the message sent, our program is blocked by the second goroutine as it is waiting for 1 second of the previous iteration. Note that `channel1` is always ready to send messages but is blocked by the delay in the second goroutine. `channel1` has to wait for 1 second for `fmt.Println(<-channel2)` to execute every time although the first goroutine may have finished entirely in less than a second! 

The expected output is shown below:

This lesson will introduce you to multi-way concurrent control in Go: the select statement. 

Introduction to Concurrency

Building Blocks of Concurrency in Go

Exam I on Mastering Concurrency in Go

Basic Concurrency Patterns in Go

Exam II on Mastering Concurrency in Go

Select Statement

Syntax

Example