Learn Multithreading with Modern C++

Learn Multithreading with Modern C++, available at $79.99, has an average rating of 4.58, with 88 lectures, based on 1220 reviews, and has 18038 subscribers.

You will learn about How to write portable multi-threaded code in C++ Basic principles of multi-threading which will be applicable in all languages Understanding of concurrency Knowledge of C++17 parallel algorithms This course is ideal for individuals who are Programmers with a good knowledge of C++ but little or no exposure to multithreading It is particularly useful for Programmers with a good knowledge of C++ but little or no exposure to multithreading.

Enroll now: Learn Multithreading with Modern C++

Summary

Title: Learn Multithreading with Modern C++

Price: $79.99

Average Rating: 4.58

Number of Lectures: 88

Number of Published Lectures: 87

Number of Curriculum Items: 94

Number of Published Curriculum Objects: 93

Original Price: £29.99

Quality Status: approved

Status: Live

What You Will Learn

How to write portable multi-threaded code in C++
Basic principles of multi-threading which will be applicable in all languages
Understanding of concurrency
Knowledge of C++17 parallel algorithms

Who Should Attend

Programmers with a good knowledge of C++ but little or no exposure to multithreading

Target Audiences

Programmers with a good knowledge of C++ but little or no exposure to multithreading

Please note that this course is currently being updated. All the videos are being re-recorded, and new material will be added. I will try to minimize disruption, but there may be times when it is unavoidable.

Multithreading is used in many areas of computing, including graphics processing, machine learning and Internet stores. An understanding of threads is essential to make full use of the capabilities of modern hardware.

C++ now provides direct support for threads, making it possible to write portable multithreaded programs which have well-defined behaviour, without requiring any external libraries.

This course thoroughly covers the basics of threading and will prepare you for more advanced work with threads. Source code is provided for all the examples. No previous knowledge of threading is required, but you should be comfortable with programming in C++ at an intermediate level, using “Modern” features such as smart pointers and move semantics.

We start with the concepts of multithreading and learn how to launch threads in C++. We look at the problems which can occur with multiple threads and how to avoid them.

C++ provides tools which allow us to work at a higher level of abstraction than system threads which share data; we cover condition variables and promises with futures. We will also look at asynchronous, lock-free and parallel programming, including atomic variables and the parallel algorithms in C++17. We will finish the course by implementing a concurrent queue and thread pool, which will bring together the material you have learnt.

There are downloadable exercises for each video, with solutions, so you can check your understanding as you learn, gaining familiarity and confidence with the material. There are also some optional assignments, which are more challenging.

I will be actively supporting the course. I will respond promptly if you have any questions or experience difficulties with the course content. Please feel free to use the Q&A feature or alternatively you can send me a private message.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Lecturer Introduction

Lecture 3: Guide to Exercises and Source Code

Chapter 2: Review of Modern C++ Features

Lecture 1: Modern C++ Overview Part One

Lecture 2: Modern C++ Overview Part Two

Lecture 3: Modern C++ Overview Part Three

Lecture 4: Modern C++ Overview Part Four

Lecture 5: Modern C++ Overview Part Five

Chapter 3: Introduction to Concurrency

Lecture 1: Concurrency Introduction

Lecture 2: Concurrency Motivation

Lecture 3: Concurrency Overview

Lecture 4: Threaded Program Structure

Lecture 5: A Brief History of C++ Concurrency

Lecture 6: Launching a Thread

Lecture 7: Thread Function with Arguments

Lecture 8: Computer with Single Processor

Lecture 9: Computer with Single Processor and Cache

Lecture 10: Computer with Multiple Processors

Lecture 11: Synchronization Issues

Chapter 4: Getting Started with Threads

Lecture 1: System Thread Interface

Lecture 2: The C++ Thread Class

Lecture 3: Managing a Thread

Lecture 4: Multiple Threads

Lecture 5: Data Races

Lecture 6: Data Race Consequences

Chapter 5: Working with shared data

Lecture 1: Critical Sections

Lecture 2: Mutex Introduction

Lecture 3: Mutex Class

Lecture 4: Internally Synchronized Class

Lecture 5: Lock Guard

Lecture 6: Unique Lock

Lecture 7: Timeouts and Mutexes

Lecture 8: Multiple Reader,Single Writer

Lecture 9: Shared Mutexes

Lecture 10: Shared Data Initialization

Lecture 11: Thread-local Data

Lecture 12: Lazy initialization

Lecture 13: Double-checked Locking

Lecture 14: Deadlock

Lecture 15: Deadlock Practical

Lecture 16: Deadlock Avoidance

Lecture 17: Deadlock Avoidance Practical

Lecture 18: Livelock

Lecture 19: Livelock Practical

Lecture 20: Mutex Conclusion

Chapter 6: Thread Synchronization

Lecture 1: Thread Coordination

Lecture 2: Thread Coordination Practical

Lecture 3: Condition Variables

Lecture 4: Condition Variables with Predicate

Lecture 5: Condition Variable Practical

Lecture 6: Futures and Promises Overview

Lecture 7: Future and Promise Classes

Lecture 8: Futures and Promises Examples

Lecture 9: Promises with Multiple Waiting Threads

Chapter 7: Atomic Types

Lecture 1: Integer Operations and Threads

Lecture 2: Atomic Types

Lecture 3: Atomic Operations

Lecture 4: Lock-free Programming

Lecture 5: Lock-free Programming Continued

Lecture 6: Lock-free Programming Practical

Lecture 7: Lock-free Programming Practical Continued

Chapter 8: Asynchronous Programming

Lecture 1: Asynchronous Programming

Lecture 2: Packaged Task

Lecture 3: The async Function

Lecture 4: The async Function and Launch Options

Lecture 5: Choosing a Thread Object

Chapter 9: Parallelism

Lecture 1: Parallelism Overview

Lecture 2: Parallelism Overview Continued

Lecture 3: Data Parallelism Practical

Lecture 4: Standard Algorithms Overview

Lecture 5: Execution Policies

Lecture 6: Algorithms and Execution Policies

Lecture 7: New Parallel Algorithms

Lecture 8: New Parallel Algorithms Continued

Lecture 9: Parallel Algorithms Practical

Lecture 10: New Parallel Algorithms Conclusion

Chapter 10: Practical Data Structures for Concurrent Programming

Lecture 1: Data Structures and Concurrency

Lecture 2: Shared Pointer

Lecture 3: Monitor Class

Lecture 4: Monitor Class Continued

Lecture 5: Semaphore

Lecture 6: Concurrent Data Queue Practical

Lecture 7: Thread Pools

Lecture 8: Thread Pool Implementation Practical

Instructors

James Raynard
Software developer and instructor, specialist in C++

Rating Distribution

1 stars: 12 votes
2 stars: 18 votes
3 stars: 94 votes
4 stars: 427 votes
5 stars: 669 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!

Menu