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

> A mutex, or a mutual exclusion prevents other processes from entering a critical section of data while a process occupies it.

We import mutex from the `sync` package in Go. `sync.mutex` has two methods:

* `.Lock()` : acquires/holds the lock
* `.Unlock()`: releases the lock



var myMutex sync.Mutex

myMutex.Lock()

//critical section 

myMutex.Unlock()


# Critical Section
Let's continue on our example of deposit/withdraw balance from the lesson on race condition. Deposit and withdraw should not happen at the same time, i.e., the variable `balance` should not be read/modified simultaneously. Therefore, every time we read the variable `balance` or update the variable `balance`, that section of code is referred to as the critical section of data. In general, the section of code which is accessing or updating the shared resources is called the critical section. Mutexes provide us with a locking mechanism which enables only one process to access the critical section at a time. 

In Go, if one goroutine is in a critical section, then the mutex will not allow any other goroutine to enter the same critical section. 

# Example

Let's look at the example below:

Let's learn about Mutex in Go and use it to solve 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

Mutex

Critical Section