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

One of the reasons why concurrency is hard to achieve is because of **data races**. 

# Data Race
> A **data race** happens when processes have to access the same variable concur­rently i.e. one process reads from a memory location while another simultaneously writes to the exact same memory location. 

The following function is an example of a data race:

package main
import "fmt"

func main() {
    number := 0;
    
    go func(){
      number++ //reading and modifying the value of 'number'
    }()

    fmt.Println(number) //reading the value of 'number'


}

We increment the value of the variable `number` i.e. we first access the value, add `1` to it and then write the new value back to the memory. `number++` takes place using an anonymous **go routine**. In the next step, we read the value of `number` and print it onto the console. However, the output of the code above turns out to be `0` because the main routine finishes itself before the goroutine has a chance to execute itself completely. We'll explore more about this concept in the second chapter. 

The point to note in the above example is that `number++` and `fmt.Println(number)` are participating in a data race as `number++` is reading from and writing to the same memory location that `fmt.Println(number)` is reading from. 

This will get us in trouble if these operations execute at the same time which is a possibility when it comes to executing code with goroutines as they are concurrent operations.  

In this lesson, you will learn about data races which in most cases lead to race conditions. 

Data Races and Race Conditions

In this lesson, you will learn about data races which in most cases lead to race conditions.

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

Data Races and Race Conditions

Data Race