In this module, you'll learn concurrency in Go and master Go parallelism for improved performance. You will also explore Go Fan-In Fan-out patterns to optimize task and data processing.

Go.tar.gz

DataRaceBuilder

temp

Golang for Programmers

Mastering concurrency in Go can make you a highly sought-after developer in today's job market, where multi-core devices are becoming common. The good news is that concurrency in Go is straightforward and efficient, thanks to Go’s robust support for concurrency out of the box. In fact, it's easier and faster to implement than in other major programming languages.
In this module, we'll begin with a general introduction to concurrency and build up to more advanced concepts like Go parallelism. We'll also dive into common patterns, including Go Fan-In Fan-out, which will make our code more efficient. By the end of this module, you'll be equipped to write high-performance, concurrent applications using Go.

Go Concurrency

> A goroutine is a function or a method which is executed concurrently with the rest of the program. 

## Syntax

You can create a goroutine by using the following syntax:




Yes, it is that simple! 

The current goroutine evaluates the input parameters to the functions/methods which are executed in the new goroutines. Even our `main()` function is a goroutine which was invoked by the implicitly created goroutine managed by Go runtime. 

## Example

Let's look at an example:

package main
import "fmt"

func WelcomeMessage(){
    fmt.Println("Welcome to Educative!")
}

func main() {
  go WelcomeMessage()
  fmt.Println("Hello World!")
}

You can never be sure about the output of the above program. Sometimes it is just `Hello World!` while at other times the output may show both the strings `Welcome to Educative!` and `Hello World!` but in a different order.  

Keep running the code and I hope you see the different kinds of output that the program generates. 

Now let's discuss what was actually happening in the above program. On **line 9**, we create a goroutine which executes the function `WelcomeMessage()` concurrently. The program then moves to **line 10** and executes `fmt.Println("Hello World!")`. Remember here that the goroutine executing `WelcomeMessage()` was also running concurrently so whether you see `Hello World!` first or `Welcome to Educative!` depends on which code finishes first. But what happens when we only have `Hello World!` as the output?

Recall that the main function is also a kind of goroutine, so when `fmt.Println("Hello World!")` executes, the `main` goroutine finishes and we exit the program regardless of what other goroutines might be doing in the background. Hence, we don't see the output from the `WelcomeMessage()` goroutine as the program exits even before the `WelcomeMessage()` function has finished.

Let's make this concept more clear in another example: 




 

> A goroutine is a function or a method which is executed concurrently with the rest of the program. 

# Syntax

You can create a goroutine by using the following syntax:




Yes, it is that simple! 

The current goroutine evaluates the input parameters to the functions/methods which are executed in the new goroutines. Even our `main()` function is a goroutine which was invoked by the implicitly created goroutine managed by Go runtime. 

# Example

Let's look at an example:

Let's get started with concurrency in Go by learning the basics of goroutines!  


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

Conclusion

Introduction to Goroutines

Syntax

Example