Shared Memory and Shared Variables
Let’s learn about shared memory, shared variables, and synchronization.
We'll cover the following
Mutex variable
Shared memory and shared variables are huge topics in concurrent programming and the most common ways for UNIX threads to communicate with each other. The same principles apply to Go and goroutines, which is what this lesson is about. A mutex variable, which is an abbreviation of mutual exclusion variable, is mainly used for thread synchronization and for protecting shared data when multiple writes can occur at the same time. A mutex works like a buffered channel with a capacity of one, which allows, at most, one goroutine to access a shared variable at any given time. This means that there is no way for two or more goroutines to be able to update that variable simultaneously. Go offers the sync.Mutex
and sync.RWMutex
data types.
Critical section
A critical section of a concurrent program is the code that cannot be executed simultaneously by all processes, threads, or, in this case, goroutines. It is the code that needs to be protected by mutexes. Therefore, identifying the critical sections of our code makes the whole programming process so much simpler that we should pay particular attention to this task. A critical section cannot be embedded into another critical section when both critical sections use the same sync.Mutex
or sync.RWMutex
variable.
Put simply, avoid at almost any cost spreading mutexes across functions because that makes it really hard to see whether we are embedding or not.
The sync.Mutex
type
The sync.Mutex
type is the Go implementation of a mutex. Its definition, which can be found in the mutex.go
file of the sync
directory, is as follows—we do not need to know the definition of sync.Mutex
in order to use it:
Get hands-on with 1200+ tech skills courses.