Golang (Go) Concurrency: Hands-On Guide

Name: Golang (Go) Concurrency: Hands-On Guide
Rating: 4.1 (12 reviews)

Practical Techniques for Efficient, Concurrent , and Scalable Software Development

Created byLeandro Franciscato

Last updated 8/2023

English

EnglishPortuguese

What you'll learn

Learners will gain a solid grasp of fundamental concepts related to concurrency in Golang, including goroutines, channels, and synchronization mechanisms
Students will learn how to implement concurrent systems effectively
Participants will become proficient in detecting and mitigating common concurrency-related issues such as data races and synchronization problems
By the end of the course, learners will be equipped with the skills to optimize the performance of their Golang applications using concurrency

Course content

3 sections • 12 lectures • 2h 9m total length

Goroutines: Introduction and Basics4:17
Launch goroutines as lightweight threads that run concurrently under the Go runtime. See how asynchronous tasks execute, with non-deterministic order, and use brief sleeps to observe concurrency.
Goroutines
Mutex: Ensuring Data Consistency3:25
Learn how a mutex from the sync package guards a critical section in Go concurrency, preventing data races as many goroutines safely increment a shared count one at a time.
Mutex
Condition Variable: Coordination Between Goroutines7:16
Learn how to coordinate goroutines in Go using a condition variable and mutex, with a producer-consumer example that uses wait and signal to manage a shared counter.
Condition Variable
Wait Groups: Synchronization and Completion16:41
Demonstrates using Go's wait groups from the sync package to coordinate goroutines, compare with mutex and condition variables, and show two clear patterns for signaling completion.
Wait Groups

Atomic Operations: Low-Level Synchronization12:56
Explore atomic operations in Go to achieve low-level synchronization by replacing mutexes in simple increments and reads, preventing data races across 1,000 goroutines, and safely updating complex values with atomic.Value.
Atomic Operations
Pool: Memory Allocation and Garbage Collection7:50
Reuse objects with Go's pool to reduce memory usage and garbage collection. Use get and put with a new function for safe concurrent access by goroutines to database connections.
Pool
Channels: Communication Between Goroutines15:20
Explore how channels enable communication and synchronization between goroutines in Go, including unbuffered and buffered channels, send and receive operations, and multiple goroutines sharing channels.
Channels
Select: Multiplexing Goroutine Communication8:27
Explore how the Go select statement multiplexes goroutine communication by waiting for multiple channels, forwarding messages to matching cases, and ensuring only one case executes at a time.
Select
Review: Recap and Practice28:30
Explore how this class guides you through building a Go web crawler that uses goroutines, channels, mutexes, waitgroups, and atomic statistics to handle http requests.

Data Race Detector: Debugging Concurrency Issues7:02
Learn how the Go data race detector identifies concurrent reads and writes to shared data using the -race flag, and see how mutexes and atomic operations resolve races.
Context: Managing Goroutine Lifecycle17:00
Explore how the context package manages goroutine lifecycles in Go, using with cancel, with timeout, with deadline, and with value for hierarchical context propagation.
Context
Congratulations0:31
Celebrate completing the course and apply the gained insights on concurrent programming with Go to your projects, stay curious, and keep coding.

Requirements

Learners should have a good understanding of the fundamentals of the Go programming language
A basic knowledge of common data structures (arrays, lists, maps) will aid in understanding the examples and exercises involving concurrent programming

Description

Unlock the potential of concurrent programming in Go with this guide. Designed for intermediate and advanced developers, this hands-on course equips you with the skills needed to create efficient, responsive, and scalable software solutions.

Dive into the world of Golang concurrency as you explore the key pillars of concurrent processing: goroutines, mutexes, condition variables, wait groups, atomic operations, channels, and more.

The course takes you further, enabling you to eliminate data races and ensure data integrity across multi-threaded applications.

How you follow this course:

All classes in this course are practical. It does not mean that you won't understand the concepts, quite the contrary! Before starting coding, I introduce you to what we're going to cover, explaining the language concepts and showing diagrams. Only after this we code.

Each class has its own code snipped attached to it, if you don't want to code along with the course, you can download the snippet and follow from there.

We also have a quiz in the end of each class, so you can test yourself and make sure you understood what was covered. It's not mandatory, as also the review class, but I highly recomend you to go through it.

Hope you enjoy it.

Who this course is for:

If you have a good understanding of Go fundamentals, this course will empower you to leverage the power of concurrency for enhanced performance and responsiveness
Backend developers who work with Golang-based server applications will find this course valuable for learning how to manage concurrent requests efficiently, ensuring scalability and responsiveness in their projects
If you have experience in other programming languages and want to transition to Go, this course will help you bridge the gap by teaching you how to apply your existing concurrency knowledge to the Go programming environment

Golang (Go) Concurrency: Hands-On Guide

What you'll learn

Explore related topics

Course content

Fundamentals of Concurrency in Golang4 lectures • 32min

Advanced Concurrency Techniques5 lectures • 1hr 13min

Optimization3 lectures • 25min

Requirements

Description

Who this course is for: