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

## What is a `WaitGroup`?

> A WaitGroup blocks a program and waits for a set of goroutines to finish before moving to the next steps of execution.  

## How to use `WaitGroup`?

We can use WaitGroups through the following functions:

* `.Add(int)`: This function takes in an integer value which is essentially the number of goroutines which the waitgroup has to wait for. This function must be called before we execute a goroutine. 
* `.Done()`: This function is called within the goroutine to signal that the goroutine has successfully executed. 
* `.Wait()`: This function blocks the program until all the goroutines specified by `Add()` have invoked `Done()` from within. 

Does this seem like a lot of information right now? Don't worry, it'll look easier once we see a sample structure to use the above functions. 
  




# What is a `WaitGroup`?

> A WaitGroup blocks a program and waits for a set of goroutines to finish before moving to the next steps of execution.  

# How to use `WaitGroup`?

We can use WaitGroups through the following functions:

* `.Add(int)`: This function takes in an integer value which is essentially the number of goroutines which the waitgroup has to wait for. This function must be called before we execute a goroutine. 
* `.Done()`: This function is called within the goroutine to signal that the goroutine has successfully executed. 
* `.Wait()`: This function blocks the program until all the goroutines specified by `Add()` have invoked `Done()` from within. 

Does this seem like a lot of information right now? Don't worry, it'll look easier once we see a sample structure to use the above functions. 
  




In this lesson, you will learn about the WaitGroups present in the "sync" package which will allow us some control over 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

WaitGroups

What is a `WaitGroup`?

How to use `WaitGroup`?