Concurrency in Go (Golang)

Concurrency in Go (Golang), available at $79.99, has an average rating of 4.43, with 78 lectures, based on 1194 reviews, and has 14779 subscribers.

You will learn about How to spin Goroutines and communicate data between them. How to avoid Race conditions and Deadlocks. How to synchronize the execution of Goroutines. How Go Scheduler works. How to build streaming pipelines with Goroutines and Channels. How to propagate data across API boundary. This course is ideal for individuals who are Students looking for Basic to Advanced Go Programming Concepts It is particularly useful for Students looking for Basic to Advanced Go Programming Concepts.

Enroll now: Concurrency in Go (Golang)

Summary

Title: Concurrency in Go (Golang)

Price: $79.99

Average Rating: 4.43

Number of Lectures: 78

Number of Published Lectures: 77

Number of Curriculum Items: 78

Number of Published Curriculum Objects: 77

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

How to spin Goroutines and communicate data between them.

How to avoid Race conditions and Deadlocks.

How to synchronize the execution of Goroutines.

How Go Scheduler works.

How to build streaming pipelines with Goroutines and Channels.

How to propagate data across API boundary.

Who Should Attend

Students looking for Basic to Advanced Go Programming Concepts

Target Audiences

Students looking for Basic to Advanced Go Programming Concepts

Questions that comes to all Developers is whether they are utilising the available Computing resource efficiently? 

Course Overview

The course could be divided into five parts.

Concurrency Primitives

Deep Dive into Concurrency Primitives

Concurrency Patterns

Context Package

Bonus Section – Interfaces

In the course we try to answer these questions.

Concurrency Primitives

What are the limitations of Threads?

What are advantages of goroutines over OS threads?

How do we avoid race condition?

How Channels are used to communicate data?

How do we implement timeout and non-blocking communication?

When do we use mutex and channels?

How to synchronise execution of goroutines?

How to detect race condition in Go?

Deep Dives into Concurrency Primitives

How Go scheduler works?

How does context switching works?

How channel send and receive works underneath?

Concurrency Patterns

How to construct streaming pipelines with Goroutines and Channels?

How to Fan-out and Fan-in computationally intensive stages?

How do we avoid Goroutine Leaks?

Context Package

How we can propagate request scoped data and cancellation signal across API boundaries?

Coding Exercises

Each concept is followed by a Coding Exercise.

Exercises blueprint are shared on Github.

Sample Applications

We will build

Blueprint of web crawler.

Image processing pipeline.

HTTP Server Timeouts with Context Package.

Bonus Section – Interfaces

How to define common behaviour between different objects as abstract type?

How Interface provides an abstraction for higher level functions?

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Course Overview

Lecture 3: Processes and Threads

Lecture 4: Why Concurrency is hard

Chapter 2: Goroutines

Lecture 1: Goroutines

Lecture 2: Clone Coding Exercise Github Repository

Lecture 3: Exercise-Hello

Lecture 4: Exercise-ClientServer

Lecture 5: WaitGroups

Lecture 6: Exercise-WaitGroup

Lecture 7: Goroutines & Closures

Lecture 8: Exercise-Closure

Lecture 9: Exercise-Closure02

Chapter 3: Deep Dive – Go Scheduler

Lecture 1: Deep Dive – Go Scheduler

Lecture 2: Deep Dive – Go Scheduler – Context Switching due to synchronous system call

Lecture 3: Deep Dive – Go Scheduler – Context Switching due to Asynchronous system call

Lecture 4: Deep Dive – Go Scheduler – Work Stealing

Chapter 4: Channels

Lecture 1: Channels

Lecture 2: Exercise – Channels

Lecture 3: Range, Buffered Channels

Lecture 4: Exercise – Range

Lecture 5: Exercise – Buffered Channel

Lecture 6: Channel Direction

Lecture 7: Exercise – Channel Direction

Lecture 8: Channel Ownership

Lecture 9: Exercise – Channel Ownership

Chapter 5: Deep Dive – Channels

Lecture 1: Deep Dive – Channels

Lecture 2: Deep Dive – Channels – Send and Recieve

Lecture 3: Deep Dive – Channels – Buffer full

Lecture 4: Deep Dive – Channels – Buffer empty

Lecture 5: Deep Dive – Channels – Unbuffer channel

Lecture 6: Deep Dive – Channels – Summary

Chapter 6: Select

Lecture 1: Select

Lecture 2: Exercise – Select

Lecture 3: Exercise – Timeout

Lecture 4: Exercise – Non-blocking communication

Chapter 7: Sync Package

Lecture 1: Mutex

Lecture 2: Exercise – Mutex

Lecture 3: Atomic

Lecture 4: Exercise – Atomic

Lecture 5: Conditional Variable

Lecture 6: Exercise – Conditional Variable – Signal

Lecture 7: Exercise – Conditional Variable – Broadcast

Lecture 8: Sync Once

Lecture 9: Exercise – Sync Once

Lecture 10: Sync Pool

Lecture 11: Exercise – Sync Pool

Chapter 8: Race Detector

Lecture 1: Race Detector

Lecture 2: Exercise – Race

Chapter 9: Web Crawler

Lecture 1: Web Crawler – Sequential

Lecture 2: Web Crawler – Concurrent

Chapter 10: Concurrency Patterns

Lecture 1: Pipelines

Lecture 2: Exercise – Pipelines

Lecture 3: Fan-out & Fan-in

Lecture 4: Exercise – Fan-out & Fan-in

Lecture 5: Cancelling Goroutines

Lecture 6: Exercise – Cancelling Goroutines

Chapter 11: Image Processing Pipeline

Lecture 1: Image Processing Sequential

Lecture 2: Image Processing Pipeline

Chapter 12: Context Package

Lecture 1: Context Package

Lecture 2: Context Package for Cancellation

Lecture 3: Context Package as Data bag

Lecture 4: Exercise – WithCancel

Lecture 5: Exercise – WithDeadline

Lecture 6: Exercise – WithTimeout

Lecture 7: Exercise – WithValue

Lecture 8: Context Package – Go Idioms

Chapter 13: HTTP Server Timeouts with Context Package

Lecture 1: HTTP Server Timeouts with Context Package

Chapter 14: Bonus Section: Interface

Lecture 1: Interface

Lecture 2: Interface-implicit

Lecture 3: Interfaces from standard library

Lecture 4: Exercise io.Writer interface

Lecture 5: Exercise Stringer interface

Lecture 6: Interface Satisfaction

Lecture 7: Type Assertion

Lecture 8: Exercise Type Assertion

Lecture 9: Empty Interface

Instructors

Deepak kumar Gunjetti
Consulting Solutions Architect, andcloud.io

Rating Distribution

1 stars: 5 votes

2 stars: 13 votes

3 stars: 132 votes

4 stars: 414 votes

5 stars: 630 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!