Mastering Multithreading Programming with Go (Golang) from Udemy

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.

"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

What's inside

Learning objectives

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.

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.

Syllabus

Introduction

Understanding Parallel Computing

More on Parallel Computing

Links and Resources for this course

Creating and using Threads

Processes, Threads and Green threads

Using Goroutines for Boids

Groundwork for our simulation

Starting our Goroutines

Memory sharing between Threads

Memory Sharing example Part 1

Memory Sharing example Part 2

Using Threads Quiz

Thread Synchronization with Mutexes

Why do we need Locking?

Using Mutexes in Boid simulation

Adding Synchronization to simulation

Readers-Writer Locks

Boid Synchronization with Readers-Writers Locks

Mutexes Quiz

Waiting for Completed tasks

Understanding WaitGroups

Concurrent file searching with WaitGroups

WaitGroup Quiz

Message passing with Channels

Thread Communication using Channels

Pipelining Example

Understanding Thread Pools

Thread Pool Example Part 1

Thread Pool Example Part 2

Shoelace algorithm explained (optional)

Channels Quiz

Synchronization using Condition Variables

What's a Condition Variable?

Parallel Algorithm for Matrix Multiplication

Implementing Parallel Matrix Multiplication Part 1

Implementing Parallel Matrix Multiplication Part 2

Condition Variable Quiz

Deadlocks

Deadlocking Robots, Philosophers and Trains

Simple Deadlock Example

Train Deadlock Example Part 1

Train Deadlock Example Part 2

Solving Deadlocks using Resource Hierarchy

Implementing Resource Hierarchy Solution

Solving Deadlocks using an Arbitrator

Implementing Arbitrator Solution

Barriers

Barriers Explained

Building a Barrier

Barriers with Matrix Multiplication

Atomic Variables

Understanding Atomic Variables

Atomic Variables Example

Building a Letter Frequency Program

Using Atomic Variables in our Example

Spinning Locks

Locking using Spinning locks

Building our own Spinning locks

Ledger Example

Implementing the Ledger Part 1

Implementing the Ledger Part 2

Good to know

Know what's good

, what to watch for

, and possible dealbreakers

Examines the impacts and applications of multithreading in software development

Perfect for those looking to write scalable and performant software

Taught by an experienced software developer with a proven track record

Appropriate for learners with some programming experience, especially in Go

Requires learners to have a basic understanding of computer architecture and operating systems

Provides a solid foundation for those seeking to advance their skills in concurrent programming

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Mastering Multithreading Programming with Go (Golang) with these activities:

Review basic concurrency concepts

Show steps

Reviewing basic concurrency concepts will help you better understand the material in this course.

Browse courses on Concurrency

Show steps

Read an article or blog post about concurrency
Watch a video tutorial about concurrency

Organize your notes and assignments

Show steps

Organizing your notes and assignments will help you stay on top of the material in this course.

Show steps

Create a folder for this course
Put your notes and assignments in the folder
Organize your notes and assignments into subfolders

Read "The Go Programming Language"

Show steps

Reading "The Go Programming Language" will give you a solid foundation in the Go programming language, which is essential for understanding multithreading in Go.

View Go Programming Language, The (Addison-Wesley... on Amazon

Show steps

Purchase or borrow a copy of "The Go Programming Language"
Read the book

Six other activities

Expand to see all activities and additional details

Show all nine activities

Join a study group for this course

Show steps

Joining a study group for this course will give you the opportunity to discuss the material with other students and get help from your peers.

Show steps

Find a study group for this course
Attend study group meetings
Participate in discussions

Run the example code for each section

Show steps

Running the example code for each section will give you a hands-on understanding of how the concepts work in practice.

Browse courses on Goroutines

Show steps

Go to the course GitHub page
Download the code for the section you are working on
Run the code

Create a simple multithreaded program

Show steps

Creating a simple multithreaded program will help you practice the basics of multithreading.

Browse courses on Goroutines

Show steps

Choose a simple task to multithread
Create a new Go project
Write the code for your multithreaded program
Test your program

Attend a meetup or conference on multithreading

Show steps

Attending a meetup or conference on multithreading will give you the opportunity to learn from experts in the field and network with other professionals.

Browse courses on Multithreading

Show steps

Find a meetup or conference on multithreading
Register for the event
Attend the event

Write a blog post about a multithreading topic

Show steps

Writing a blog post about a multithreading topic will help you solidify your understanding of the topic and share your knowledge with others.

Browse courses on Goroutines

Show steps

Choose a multithreading topic to write about
Research the topic
Write your blog post
Publish your blog post

Build a multithreaded web application

Show steps

Building a multithreaded web application will give you practical experience with using multithreading in a real-world application.

Browse courses on Goroutines

Show steps

Choose a web framework that supports multithreading
Create a new web application project
Write the code for your multithreaded web application
Test your web application
Deploy your web application

Career center

Learners who complete Mastering Multithreading Programming with Go (Golang) will develop knowledge and skills that may be useful to these careers:

Concurrency Architect

A Concurrency Architect designs and implements software systems that can take advantage of multiple processors or cores to improve performance and efficiency. The course Mastering Multithreading Programming with Go (Golang) provides a deep dive into the concepts and tools needed to develop concurrent and parallel programs, including goroutines, mutexes, reader writers locks, waitgroups, channels, condition variables and more. By understanding how to manage concurrency effectively, Concurrency Architects can create high-performance software that can handle complex and demanding workloads.

See salaries and explore the career path for Concurrency Architect

Multithreading Developer

A Multithreading Developer specializes in developing software that utilizes multiple threads of execution to improve performance and efficiency. The course Mastering Multithreading Programming with Go (Golang) provides a comprehensive overview of multithreading programming, covering topics such as creating and using threads, memory sharing between threads, thread synchronization with mutexes and readers-writers locks, waiting for completed tasks with waitgroups, message passing with channels, synchronization using condition variables, deadlocks, barriers, atomic variables, and spinning locks. With this knowledge, Multithreading Developers can design and implement robust and scalable software systems.

See salaries and explore the career path for Multithreading Developer

Software Engineer

A Software Engineer designs, develops, and maintains software systems. The course Mastering Multithreading Programming with Go (Golang) provides a solid foundation in multithreading programming, which is becoming increasingly important as software systems become more complex and demanding. By understanding how to develop concurrent and parallel programs, Software Engineers can create high-performance software that can handle complex and demanding workloads.

See salaries and explore the career path for Software Engineer

High-Performance Computing Engineer

A High-Performance Computing Engineer designs and develops software and hardware systems that can handle complex and demanding workloads. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance software. By understanding how to manage concurrency effectively, High-Performance Computing Engineers can create software that can take advantage of multiple processors or cores to improve performance and efficiency.

See salaries and explore the career path for High-Performance Computing Engineer

Systems Programmer

A Systems Programmer develops and maintains operating systems and other low-level software. The course Mastering Multithreading Programming with Go (Golang) provides a comprehensive overview of multithreading programming, covering topics such as creating and using threads, memory sharing between threads, thread synchronization with mutexes and readers-writers locks, waiting for completed tasks with waitgroups, message passing with channels, synchronization using condition variables, deadlocks, barriers, atomic variables, and spinning locks. With this knowledge, Systems Programmers can develop robust and efficient operating systems and other low-level software.

See salaries and explore the career path for Systems Programmer

Database Architect

A Database Architect designs and implements database systems. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance database systems. By understanding how to manage concurrency effectively, Database Architects can create database systems that can handle complex and demanding workloads.

See salaries and explore the career path for Database Architect

DevOps Engineer

A DevOps Engineer automates and integrates software development and IT operations. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance software systems. By understanding how to manage concurrency effectively, DevOps Engineers can create software systems that can be deployed and operated efficiently.

See salaries and explore the career path for DevOps Engineer

Cloud Engineer

A Cloud Engineer designs and implements cloud-based solutions. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance cloud-based solutions. By understanding how to manage concurrency effectively, Cloud Engineers can create cloud-based solutions that can handle complex and demanding workloads.

See salaries and explore the career path for Cloud Engineer

Machine Learning Engineer

A Machine Learning Engineer develops and deploys machine learning models. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance machine learning models. By understanding how to manage concurrency effectively, Machine Learning Engineers can create machine learning models that can be trained and deployed efficiently.

See salaries and explore the career path for Machine Learning Engineer

Data Engineer

A Data Engineer designs and implements data pipelines. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance data pipelines. By understanding how to manage concurrency effectively, Data Engineers can create data pipelines that can handle complex and demanding workloads.

See salaries and explore the career path for Data Engineer

Computer Scientist

A Computer Scientist researches and develops new computer technologies. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is an essential part of modern computer science. By understanding how to manage concurrency effectively, Computer Scientists can develop new computer technologies that are more efficient and scalable.

See salaries and explore the career path for Computer Scientist

Computer Programmer

A Computer Programmer develops and maintains software programs. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance software programs. By understanding how to manage concurrency effectively, Computer Programmers can create software programs that are scalable and efficient.

See salaries and explore the career path for Computer Programmer

Software Architect

A Software Architect designs and implements software systems. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance software systems. By understanding how to manage concurrency effectively, Software Architects can create software systems that are scalable and efficient.

See salaries and explore the career path for Software Architect

Systems Administrator

A Systems Administrator maintains and operates computer systems. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is becoming increasingly important as computer systems become more complex and demanding. By understanding how to manage concurrency effectively, Systems Administrators can maintain and operate computer systems more efficiently.

See salaries and explore the career path for Systems Administrator

Web Developer

A Web Developer designs and develops websites. The course Mastering Multithreading Programming with Go (Golang) provides a deep understanding of multithreading programming, which is essential for developing high-performance web applications. By understanding how to manage concurrency effectively, Web Developers can create web applications that are scalable and efficient.

See salaries and explore the career path for Web Developer