Concurrency In Go (Golang)

[martinstronis654]

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

Bitte Anmelden oder Registrieren um Code Inhalt zu sehen!