Concurrency in Modern C++ : Crash Course ( including C++20 )

Focused View

RougeNeuron Academy

1:57:30

67 View

1 - Introduction

1 - Course Objectives.mp4

03:37

2 - Managing Threads C11 onwards

2 - Launching Threads.mp4

04:44

3 - Passing arguments to threads.mp4

00:57

4 - Member fuctions of stdthread C11 and stdjthread C20.mp4

04:56

5 - Cooperative Cancellation feature released in C20.mp4

03:41

6 - Cooperative Cancellation General workflow possible in programs using C20.mp4

03:22

7 - Practical considerations of using threads in C 11141720.mp4

02:56

8 - When to use stdasync.mp4

03:15

3 - Synchronization in multhreaded applications using C concurrency features

9 - Overview of synchronization mechanisms.mp4

00:57

10 - Introduction to latches introduced in C20.mp4

01:33

11 - Code example of latches needs C20.mp4

03:06

12 - Use cases of stdlatch in programs using C20.mp4

02:30

13 - introduction to barriers introduced in C20.mp4

01:02

14 - Code example of stdbarrier needs C20.mp4

03:47

15 - Use cases of stdbarrier in programs using C20.mp4

01:21

4 - Futures C11 onwards

16 - Introduction to futures in Modern C.mp4

02:15

17 - Member functions of stdfuture.mp4

02:19

18 - Blocking and Polling usage of stdfuture.mp4

01:48

19 - Member functions of stdpromise.mp4

02:01

20 - Passing data using stdfuture and stdpromise.mp4

02:03

21 - Passing exception using stdfuture and stdpromise.mp4

00:34

22 - Futures in C are single shot.mp4

00:50

23 - Shared futures.mp4

00:45

24 - stdasync revisted as concurrency mechanism.mp4

01:16

5 - Mutex C11 onwards

25 - Introduction to stdmutex.mp4

03:58

26 - Locks and Mutexes in modern C for seamless life time management.mp4

02:53

27 - Code example of locks and mutexes in modern C.mp4

04:00

27 - Mastering Concurrent Data Structure Design with Modern C.txt

6 - Conditional Variables C11 onwards

28 - Busy waiting mechanism.mp4

02:30

29 - Conditional Variables in modern C.mp4

02:42

30 - Cooperative cancellation using conditional variables using C20.mp4

01:49

7 - Semaphore C20 onwards

31 - Introduction to Semphores since C20.mp4

02:48

32 - Member functions of stdsemaphore since C 20.mp4

01:43

33 - Using semaphores in programs built with C20.mp4

01:42

8 - Atomics C11 onwards

34 - Basics of Atomics.mp4

04:00

35 - Overloaded operators with atomics.mp4

03:32

36 - Cautions while using atomic overloads.mp4

01:55

37 - Member functions of atomics.mp4

02:14

38 - More member functions of atomics.mp4

02:52

39 - C memory model deep dive.txt

39 - Summary and advice while working with atomics.mp4

02:02

9 - Parallel Algorithms since C17

40 - Introduction to parallel algorithms.mp4

02:15

41 - Execution policies for parallel algorithms C17 and C20.mp4

03:11

42 - Quick demo parallel algorithms using concurrency.mp4

01:03

10 - Coroutines as shipped in C20

43 - Coroutines Disclaimer.mp4

01:50

44 - Basic flow diagram of control of coroutines in C20.mp4

04:07

45 - Member functions of coroutines task structure shipped in C20.mp4

01:17

46 - Flowchart of coroutines execution using the API availble in C20.mp4

04:54

11 - Closing remarks

47 - Third party libraries can be used with C 11 C14 C17 C20.mp4

01:50

48 - Conclusion.mp4

00:48

49 - Bonus Lecture.html

Description

C++20, Multithreading, Concurrency, Modern C++, C++11,C++14, C++17, Parallel algorithms, Coroutines, Synchronization

What You'll Learn?

Mastered the fundamentals of C++ concurrency syntax, enabling you to write efficient and high-performance concurrent code with confidence.
Gained hands-on experience with the latest C++20 concurrency features, such as coroutines, cooperative cancellation, std::jthread, semaphore, barrier, and latch
Enhanced your problem-solving skills by learning how to leverage modern C++ concurrency techniques to tackle complex and time-sensitive tasks in your projects.
Acquired the ability to identify and apply the most suitable concurrency tools for various scenarios, ensuring that your code is both maintainable and scalable.
Developed a strong foundation in C++ concurrency that will serve as a stepping stone for further exploration and mastery of advanced topics in concurrent and pa

Who is this for?

Novice C++ developers: If you've recently learned the basics of C++ programming and are eager to expand your knowledge and skills, this course is perfect for you. Our weekend crash course will quickly introduce you to the world of concurrency, allowing you to harness its power in your future projects.

Self-taught programmers: For those who have learned C++ through online resources or personal projects but have not yet delved into concurrency, this course will bridge the gap. By focusing on syntax and practical examples, you'll gain a solid understanding of concurrency in modern C++ without getting lost in complex theories.

Professionals transitioning to C++: If you're a programmer experienced in other languages and have recently begun working with C++, this course will help you quickly grasp C++ concurrency concepts. This knowledge will make you more efficient and versatile in your new programming environment.

Busy developers seeking a quick refresher: If you have some experience with C++ but haven't worked with concurrency in a while or are unfamiliar with the latest C++20 features, this weekend crash course is an ideal way to quickly update your skills. You'll learn the most important aspects of modern C++ concurrency, enabling you to apply them immediately in your projects.

More details

Description
Welcome to "Turbocharge Your C++ with Concurrency: A Weekend Crash Course"!
Are you a programmer who has recently learned C++ and wants to unlock the true power of modern C++ concurrency? Look no further! In just one weekend, we will help you quickly grasp the essentials of C++ concurrency and supercharge your coding skills. These are skills that tools like ChatGPT will take years to develop.
In this fast-paced and intensive course, we will focus exclusively on the syntax of C++ concurrency, allowing you to understand and apply the features efficiently in your own projects. We know your time is valuable, so we've carefully designed short, easy-to-follow lectures that introduce syntax and explain its usage through concise examples. This way, you'll maximize your learning experience without getting bogged down in unnecessary details.
Our curriculum includes the latest C++20 features, ensuring you are up-to-date with cutting-edge concurrency tools. You'll learn about coroutines, cooperative cancellation, std::jthread, semaphore, barrier, and latches. These powerful features will take your C++ skills to the next level and make you a more effective and competitive programmer in today's fast-evolving tech landscape.
This course is perfect for you if you've just learned C++ and are eager to dive into the world of concurrency without spending weeks on theory and complex projects. By the end of this weekend, you'll have a solid understanding of modern C++ concurrency syntax and be ready to apply it in real-world scenarios.
So, what are you waiting for? Enroll now, and let's turbocharge your C++ skills with this weekend's crash course!

Why is Mastering Modern C++ Concurrency Features Crucial for Today's Programmers?
Understanding and utilizing modern concurrency features built into the C++ language is paramount in today's fast-paced, technology-driven world. Writing efficient, high-performance concurrent code is a highly sought-after skill as software applications and systems become increasingly complex and resource-intensive. By learning modern C++ concurrency features, you will unlock the true potential of multicore processors, significantly improving the performance and responsiveness of your applications. This knowledge sets you apart as a programmer and allows you to tackle complex, real-world problems more effectively. By investing in your skills and mastering modern C++ concurrency, you will stay ahead of the curve, becoming a valuable asset in the competitive software development landscape and opening up a world of opportunities in your career.

Evolution of the C++ Memory Model
The C++ concurrency model has evolved significantly from C++11 to C++20, introducing new language features and library components that provide more powerful and flexible support for concurrent programming. Here are some of the significant changes that have occurred:
C++11: C++11 introduced the first set of language-level concurrency features, including the std::thread class for creating and managing threads, mutexes and condition variables for synchronization, and atomic types for lock-free programming. C++11 also defined the Sequential Consistency-Data Race Free (SC-DRF) memory model, which guarantees correct behavior for well-synchronized programs.
C++14: C++14 introduced several improvements to the concurrency features introduced in C++11, including new constructors and member functions for std::thread, support for heterogeneous lookup in concurrent containers, and enhancements to the std::atomic template.
C++17: C++17 introduced several new concurrency features and enhancements, including support for parallel algorithms in the Standard Template Library (STL), structured bindings for returning multiple values from std::thread functions, and support for shared_mutex for shared read access and exclusive write access. C++17 also introduced a new memory model that provides stronger guarantees for atomic operations.
C++20: C++20 builds on the concurrency features introduced in previous language versions and adds several new features and enhancements. These include the atomic_ref class, which provides a safer way to access shared variables without the need for explicit synchronization, improvements to the memory model to reduce the need for explicit fences and barriers, and enhancements to the coroutines library that make it easier to write asynchronous code.
The evolution of the C++ concurrency model from C++11 to C++20 has provided developers with a more powerful and flexible set of tools for writing efficient and correct concurrent programs. The new language features and library components introduced in each version have addressed many of the challenges and limitations of earlier versions. In addition, they have made concurrent programming in C++ more accessible and easier to use.
Who this course is for:
Novice C++ developers: If you've recently learned the basics of C++ programming and are eager to expand your knowledge and skills, this course is perfect for you. Our weekend crash course will quickly introduce you to the world of concurrency, allowing you to harness its power in your future projects.
Self-taught programmers: For those who have learned C++ through online resources or personal projects but have not yet delved into concurrency, this course will bridge the gap. By focusing on syntax and practical examples, you'll gain a solid understanding of concurrency in modern C++ without getting lost in complex theories.
Professionals transitioning to C++: If you're a programmer experienced in other languages and have recently begun working with C++, this course will help you quickly grasp C++ concurrency concepts. This knowledge will make you more efficient and versatile in your new programming environment.
Busy developers seeking a quick refresher: If you have some experience with C++ but haven't worked with concurrency in a while or are unfamiliar with the latest C++20 features, this weekend crash course is an ideal way to quickly update your skills. You'll learn the most important aspects of modern C++ concurrency, enabling you to apply them immediately in your projects.

User Reviews

Rating

average 0

Total votes0

Focused display

C++

Programming Fundamentals

RougeNeuron Academy

Instructor's Courses

About Instructor=============As a professional programmer with over 17 years of experience, I have a Master of Science degree in Electrical Engineering and a strong interest in Distributed Systems, Algorithms, Deep Learning, Performance, and Optimization. My journey as a programmer started during my school days with Logo software, continued with assembly, BASIC, and Pascal during high school, and concluded with interdisciplinary research as part of my M.S.Currently, I am working on online education initiatives and have experience adapting to dynamic and versatile startup work environments. I am comfortable working with open problem assignments and operating in an intrapreneurial role. Additionally, I have built big data (Spark) and data science (TensorFlow) skills that overlap with my M.S. curriculum and programming work experience.My thesis focused on a geographically distributed network of sensors synchronized with nanosecond precision, collecting data for a machine learning system to detect a cosmic event. I have extensive experience with Linux and C++ (familiar with C++14/17/20 features), and I enjoy exploring new languages and frameworks with the help of active developer communities, resourceful websites, public code repositories, and YouTube channels.My interests span Deep Learning, Databases, Networking, Algorithms, Performance, Kubernetes, and Optimization. Follow on the Website, Youtube, and LinkedIn.

Udemy

View courses Udemy

Students take courses primarily to improve job-related skills.Some courses generate credit toward technical certification. Udemy has made a special effort to attract corporate trainers seeking to create coursework for employees of their company.