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

In this chapter, we'll look at some concurrency patterns that can come in handy while we write concurrent code. 

Let's begin with generators. Generators return the next value in a sequence each time they are called. This means that each value is available as an output before the generator computes the next value. Hence, this pattern is used to introduce parallelism in our program. 

Have a look at the simple example below:

package main

import (
	"fmt"
)

func foo() <-chan string { 
	mychannel := make(chan string)

	go func() {
		for i := 0; ; i++ {
			mychannel <- fmt.Sprintf("%s %d", "Counter at : ", i)
		}
	}()

	return mychannel // returns the channel as returning argument 
}

func main() {
	mychannel := foo() // foo() returns a channel.

	for i := 0; i < 5; i++ {
		fmt.Printf("%q\n", <-mychannel)
	}

	fmt.Println("Done with Counter")
}



In the code above, we use a generator as a function which returns a channel. The `foo()` function, when invoked on **line 20**, calls a goroutine which sends a string onto the channel on **line 12**. The string contains the value of `i` which is incremented in every iteration before being sent to the channel. As the goroutine executes concurrently, the program returns `mychannel` immediately to the main routine. Then `mychannel` receives the data on the channel one by one on **line 23** as it is being sent by the goroutine. In conclusion, both the goroutine and the main routine can execute concurrently as we print the value of the counter as soon as we receive it while the goroutine simultaneously computes the next value.  

I hope you are with me so far. Let's extend this pattern to a concept where we think of the channel as a handle on a service. 



Let's study our first pattern​ of concurrency, which is about generators that return channels as returning argument. 

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

Generator Pattern