Learn about Multithreading, Concurrency & Parallel programming with practical and fun examples in Google's Go Lang. The mood in the meeting on the 12th floor of an international investment bank was as bleak as it gets. The developers of the firm met to discuss the best way forward after a critical core application failed and caused a system wide outage.
Mastering Multithreading Programming with Go (Golang)
5h 24m 43s
English
Paid
"Guys, we have a serious issue here. I found out that the outage was caused by a race condition in our code, introduced a while ago and triggered last night." says Mark Adams, senior developer.
The room goes silent. The cars outside the floor to ceiling windows slowly and silently creep along in the heavy city traffic. The senior developers immediately understand the severity of the situation, realizing that they will now be working around the clock to fix the issue and sort out the mess in the datastore. The less experienced developers understand that a race condition is serious but don't know exactly what causes it and therefore keep their mouths shut.
Eventually Brian Holmes, delivery manager, breaks the silence with "The application has been running for months without any problems, we haven't released any code recently, how is it possible that the software just broke down?!"
Everyone shakes their heads and goes back to their desk leaving Brian in the room alone, puzzled. He takes out his phone and googles "race condition".
Sound familiar? How many times have you heard another developer talking about using threads and concurrent programming to solve a particular problem but out of fear you stayed out of the discussion?
Here's the little secret that senior developers will never share... Multithreading programming is not much harder than normal programming. Developers are scared of concurrent programming because they think it is an advanced topic that only highly experienced developers get to play with.
This is far from the truth. Our minds are very much used to dealing with concurrency. In fact we do this in our everyday life without any problem but somehow we struggle to translate this into our code. One of the reasons for this is that we're not familiar with the concepts and tools available to us to manage this concurrency. This course is here to help you understand how to use multithreading tools and concepts to manage your parallel programming. It is designed to be as practical as possible. We start with some theory around parallelism and then explain how the operating system handles multiple processes and threads. Later we move on to explain the multiple tools available by solving example problems using multithreading.
In this course we use Google's Go programming language with its goroutines, however the concepts learned here can be applied to most programming languages.
All code in this course can be found on github, username/project: cutajarj/multithreadingingo
Requirements:
Some experience of programming in Go (enough if you know how to use functions, loops, arrays and a bit of pointers).
Recent version of Go installed.
Being able to do 50 push-ups while shouting a unique prime number on each rep (just kidding).
Who this course is for:
- Developers who want to take their career to the next level by improving their skills and learning about concurrent multithreading programming.
- College students currently learning about parallel computing who want to see how concepts learned in class relate to practice.
- Experienced developers that have recently started working with Go and want to discover the multithreading tools available.
- Delivery managers called Brian Holmes.
What you'll learn:
- Discover how to create responsive and high performance software.
- See how to use multithreading for modeling certain types of problems and simulations.
- Develop programs with Golang that are highly Concurrent and Parallel.
- Understand the advantages, limits and properties of Parallel computing.
- Improve your programming skills in Go with more advanced, mulithreading topics.
- Learn about goroutines, mutexes, reader writers locks, waitgroups, channels, condition variables and more.
Additional
Весь код в этом курсе можно найти на github, имя пользователя / проект: cutajarj/multithreadingingo
About the Author: Udemy
Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.
Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.
Watch Online 45 lessons
0:00
/ #1: Understanding Parallel Computing
All Course Lessons (45)
| # | Lesson Title | Duration | Access |
|---|---|---|---|
| 1 | Understanding Parallel Computing Demo | 04:24 | |
| 2 | More on Parallel Computing | 05:51 | |
| 3 | Processes, Threads and Green threads | 12:28 | |
| 4 | Using Goroutines for Boids | 04:19 | |
| 5 | Groundwork for our simulation | 05:14 | |
| 6 | Starting our Goroutines | 08:54 | |
| 7 | Memory sharing between Threads | 06:47 | |
| 8 | Memory Sharing example Part 1 | 05:38 | |
| 9 | Memory Sharing example Part 2 | 06:41 | |
| 10 | Why do we need Locking? | 09:00 | |
| 11 | Using Mutexes in Boid simulation | 05:47 | |
| 12 | Adding Synchronization to simulation | 05:27 | |
| 13 | Readers-Writer Locks | 07:13 | |
| 14 | Boid Synchronization with Readers-Writers Locks | 07:14 | |
| 15 | Understanding WaitGroups | 06:43 | |
| 16 | Concurrent file searching with WaitGroups | 07:50 | |
| 17 | Thread Communication using Channels | 10:08 | |
| 18 | Pipelining Example | 12:32 | |
| 19 | Understanding Thread Pools | 08:00 | |
| 20 | Thread Pool Example Part 1 | 08:18 | |
| 21 | Thread Pool Example Part 2 | 06:07 | |
| 22 | What's a Condition Variable? | 07:01 | |
| 23 | Parallel Algorithm for Matrix Multiplication | 09:28 | |
| 24 | Implementing Parallel Matrix Multiplication Part 1 | 07:06 | |
| 25 | Implementing Parallel Matrix Multiplication Part 2 | 06:07 | |
| 26 | Deadlocking Robots, Philosophers and Trains | 08:30 | |
| 27 | Simple Deadlock Example | 04:18 | |
| 28 | Train Deadlock Example Part 1 | 03:41 | |
| 29 | Train Deadlock Example Part 2 | 08:30 | |
| 30 | Solving Deadlocks using Resource Hierarchy | 07:09 | |
| 31 | Implementing Resource Hierarchy Solution | 06:55 | |
| 32 | Solving Deadlocks using an Arbitrator | 08:11 | |
| 33 | Implementing Arbitrator Solution | 05:37 | |
| 34 | Barriers Explained | 07:46 | |
| 35 | Building a Barrier | 08:03 | |
| 36 | Barriers with Matrix Multiplication | 07:46 | |
| 37 | Understanding Atomic Variables | 08:58 | |
| 38 | Atomic Variables Example | 03:00 | |
| 39 | Building a Letter Frequency Program | 07:25 | |
| 40 | Using Atomic Variables in our Example | 07:04 | |
| 41 | Locking using Spinning locks | 06:16 | |
| 42 | Building our own Spinning locks | 04:55 | |
| 43 | Ledger Example | 09:51 | |
| 44 | Implementing the Ledger Part 1 | 06:43 | |
| 45 | Implementing the Ledger Part 2 | 09:48 |
Unlock unlimited learning
Get instant access to all 44 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.
Learn more about subscriptionRelated courses
-
Updated 2y agoGo Bootcamp: Master Golang with 1000+ Exercises and Projects
By: UdemyDeeply understand and master the Go Programming Language (Golang) from scratch 1000+ hands-on exercises and projects.15h 27m -
Updated 2y agoPractical Go Foundations
By: Ardan LabsThis introductory course explores topics like strings, REST APIs, error handling, testing, sorting, and more!13h 9m5/5 -
Updated 11mo agoBuilding Levenue
By: Anthony GGLive screen recordings and explanations on how we are step by step building the infrastructure of my million-dollar company - levenue.com.6h 55m0/5
Frequently asked questions
What are the prerequisites for enrolling in this course?
Prospective students should have a solid understanding of programming concepts and some experience with Go (Golang). Familiarity with basic concurrency principles will be beneficial, although the course covers foundational topics like processes, threads, and goroutines.
What projects or exercises will students complete in the course?
Students will work on practical examples such as a Boids simulation using goroutines and mutexes, a concurrent file search using WaitGroups, and a parallel algorithm for matrix multiplication. These exercises are designed to reinforce concepts of multithreading, concurrency, and parallel programming.
Who is the target audience for this course?
This course is designed for software developers and engineers interested in enhancing their skills in multithreading and concurrency using Go. It's suitable for those who want to apply these concepts to real-world applications, particularly in performance-critical systems.
How does this course compare in depth and scope to other programming courses?
The course offers a focused exploration of multithreading and concurrency in Go, with 45 lessons covering topics from basic parallel computing to advanced synchronization techniques like mutexes and atomic variables. It emphasizes practical implementation and real-world scenarios more than introductory Go courses.
What specific tools or platforms will I use during the course?
Students will primarily work with Go's goroutines, channels, and synchronization primitives such as mutexes and WaitGroups. The course also involves tools like thread pools and condition variables to manage concurrency effectively in Go applications.
What topics are not covered in this course?
The course does not cover basic Go programming from scratch or non-concurrency-related aspects of Go. It assumes prior knowledge of general Go development and focuses specifically on concurrency and parallel programming techniques.
How can the skills learned in this course benefit my career?
Mastering concurrency and parallel programming in Go can significantly enhance your ability to develop efficient, scalable applications. These skills are valuable in performance-critical industries such as finance, gaming, and data processing, and are transferable to other programming languages that support concurrency.