Concurrency In Go (Golang)
Last updated 5/2022
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 1.05 GB | Duration: 5h 0m
Learn the Why's and How's of concurrency in Go.
What you'll 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.
Requirements
Basic knowledge of Go Programming Language like loops, functions, methods.
Installation of Go compiler and any IDE on the laptop.
Description
Questions that comes to all Developers is whether they are utilising the available Computing resource efficiently? Course OverviewThe course could be divided into five parts.Concurrency PrimitivesDeep Dive into Concurrency PrimitivesConcurrency PatternsContext PackageBonus Section - InterfacesIn the course we try to answer these questions.Concurrency PrimitivesWhat 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 PrimitivesHow Go scheduler works?How does context switching works?How channel send and receive works underneath?Concurrency PatternsHow 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 PackageHow we can propagate request scoped data and cancellation signal across API boundaries?Coding ExercisesEach concept is followed by a Coding Exercise.Exercises blueprint are shared on Github.Sample ApplicationsWe will buildBlueprint of web crawler.Image processing pipeline.HTTP Server Timeouts with Context Package.Bonus Section - InterfacesHow to define common behaviour between different objects as abstract type?How Interface provides an abstraction for higher level functions?
Overview
Section 1: Introduction
Lecture 1 Introduction
Lecture 2 Course Overview
Lecture 3 Processes and Threads
Lecture 4 Why Concurrency is hard
Section 2: Goroutines
Lecture 5 Goroutines
Lecture 6 Clone Coding Exercise Github Repository
Lecture 7 Exercise-Hello
Lecture 8 Exercise-ClientServer
Lecture 9 WaitGroups
Lecture 10 Exercise-WaitGroup
Lecture 11 Goroutines & Closures
Lecture 12 Exercise-Closure
Lecture 13 Exercise-Closure02
Section 3: Deep Dive - Go Scheduler
Lecture 14 Deep Dive - Go Scheduler
Lecture 15 Deep Dive - Go Scheduler - Context Switching due to synchronous system call
Lecture 16 Deep Dive - Go Scheduler - Context Switching due to Asynchronous system call
Lecture 17 Deep Dive - Go Scheduler - Work Stealing
Section 4: Channels
Lecture 18 Channels
Lecture 19 Exercise - Channels
Lecture 20 Range, Buffered Channels
Lecture 21 Exercise - Range
Lecture 22 Exercise - Buffered Channel
Lecture 23 Channel Direction
Lecture 24 Exercise - Channel Direction
Lecture 25 Channel Ownership
Lecture 26 Exercise - Channel Ownership
Section 5: Deep Dive - Channels
Lecture 27 Deep Dive - Channels
Lecture 28 Deep Dive - Channels - Send and Recieve
Lecture 29 Deep Dive - Channels - Buffer full
Lecture 30 Deep Dive - Channels - Buffer empty
Lecture 31 Deep Dive - Channels - Unbuffer channel
Lecture 32 Deep Dive - Channels - Summary
Section 6: Select
Lecture 33 Select
Lecture 34 Exercise - Select
Lecture 35 Exercise - Timeout
Lecture 36 Exercise - Non-blocking communication
Section 7: Sync Package
Lecture 37 Mutex
Lecture 38 Exercise - Mutex
Lecture 39 Atomic
Lecture 40 Exercise - Atomic
Lecture 41 Conditional Variable
Lecture 42 Exercise - Conditional Variable - Signal
Lecture 43 Exercise - Conditional Variable - Broadcast
Lecture 44 Sync Once
Lecture 45 Exercise - Sync Once
Lecture 46 Sync Pool
Lecture 47 Exercise - Sync Pool
Section 8: Race Detector
Lecture 48 Race Detector
Lecture 49 Exercise - Race
Section 9: Web Crawler
Lecture 50 Web Crawler - Sequential
Lecture 51 Web Crawler - Concurrent
Section 10: Concurrency Patterns
Lecture 52 Pipelines
Lecture 53 Exercise - Pipelines
Lecture 54 Fan-out & Fan-in
Lecture 55 Exercise - Fan-out & Fan-in
Lecture 56 Cancelling Goroutines
Lecture 57 Exercise - Cancelling Goroutines
Section 11: Image Processing Pipeline
Lecture 58 Image Processing Sequential
Lecture 59 Image Processing Pipeline
Section 12: Context Package
Lecture 60 Context Package
Lecture 61 Context Package for Cancellation
Lecture 62 Context Package as Data bag
Lecture 63 Exercise - WithCancel
Lecture 64 Exercise - WithDeadline
Lecture 65 Exercise - WithTimeout
Lecture 66 Exercise - WithValue
Lecture 67 Context Package - Go Idioms
Section 13: HTTP Server Timeouts with Context Package
Lecture 68 HTTP Server Timeouts with Context Package
Section 14: Bonus Section: Interface
Lecture 69 Interface
Lecture 70 Interface-implicit
Lecture 71 Interfaces from standard library
Lecture 72 Exercise io.Writer interface
Lecture 73 Exercise Stringer interface
Lecture 74 Interface Satisfaction
Lecture 75 Type Assertion
Lecture 76 Exercise Type Assertion
Lecture 77 Empty Interface
Students looking for Basic to Advanced Go Programming Concepts
Screenshot
Concurrency In Go (Golang)
