C++ Concurrency in Action, 2nd Video Edition

C++ Concurrency in Action, 2nd Video Edition
C++ Concurrency in Action, 2nd Video Edition

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 13h 05m | 3.64 GB
eLearning | Skill level: All Levels


“This book should be on every C++ programmer’s desk. It’s clear, concise, and valuable.”
Rob Green, Bowling Green State University

This bestseller has been updated and revised to cover all the latest changes to C++ 14 and 17! C++ Concurrency in Action, Second Edition teaches you everything you need to write robust and elegant multithreaded applications in C++17.

You choose C++ when your applications need to run fast. Well-designed concurrency makes them go even faster. C++ 17 delivers strong support for the multithreaded, multiprocessor programming required for fast graphic processing, machine learning, and other performance-sensitive tasks. This exceptional book/course unpacks the features, patterns, and best practices of production-grade C++ concurrency.

C++ Concurrency in Action, Second Edition is the definitive guide to writing elegant multithreaded applications in C++. Updated for C++ 17, it carefully addresses every aspect of concurrent development, from starting new threads to designing fully functional multithreaded algorithms and data structures. Concurrency master Anthony Williams presents examples and practical tasks in every chapter, including insights that will delight even the most experienced developer.

Inside:

  • Full coverage of new C++ 17 features
  • Starting and managing threads
  • Synchronizing concurrent operations
  • Designing concurrent code
  • Debugging multithreaded applications

This course is written for intermediate C and C++ developers. No prior experience with concurrency required.

Anthony Williams has been an active member of the BSI C++ Panel since 2001 and is the developer of the just::thread Pro extensions to the C++ 11 thread library.

A thorough presentation of C++ concurrency capabilities.
Maurizio Tomasi, University of Milan

Highly recommended for programmers who want to further their knowledge of the latest C++ standard.
Frédéric Flayol, 4Pro Web C++

The guide contains snippets for everyday use in your own projects and to help take your concurrency C++ skills from the Padawan to the Jedi level.
Jura Shikin, IVI Technologies

+ Table of Contents

1 What is concurrency
2 Approaches to concurrency
3 Why use concurrency
4 Concurrency and multithreading in C++
5 Efficiency in the C++ Thread Library
6 Getting started
7 Basic thread management
8 Waiting for a thread to complete
9 Passing arguments to a thread function
10 Transferring ownership of a thread
11 Choosing the number of threads at runtime
12 Identifying threads
13 Problems with sharing data between threads
14 Protecting shared data with mutexes
15 Spotting race conditions inherent in interfaces Part 1
16 Spotting race conditions inherent in interfaces Part 2
17 Deadlock – the problem and a solution
18 Further guidelines for avoiding deadlock Part 1
19 Further guidelines for avoiding deadlock Part 2
20 Flexible locking with std – -unique lock
21 Locking at an appropriate granularity
22 Alternative facilities for protecting shared data
23 Protecting rarely updated data structures
24 Waiting for an event or other condition
25 Building a thread-safe queue with condition variables
26 Waiting for one-off events with futures
27 Associating a task with a future
28 Saving an exception for the future
29 Waiting with a time limit
30 Time points
31 Using synchronization of operations to simplify code
32 Synchronizing operations with message passing
33 Continuation-style concurrency with the Concurrency TS
34 Chaining continuations
35 Waiting for the first future in a set with when any
36 std – -experimental – -barrier – a basic barrier
37 Memory model basics
38 Atomic operations and types in C++
39 Operations on std – -atomic flag
40 Operations on std – -atomic bool
41 Operations on standard atomic integral types
42 Free functions for atomic operations
43 Synchronizing operations and enforcing ordering
44 Memory ordering for atomic operations Part 1
45 Memory ordering for atomic operations Part 2
46 Memory ordering for atomic operations Part 3
47 Memory ordering for atomic operations Part 4
48 Release sequences and synchronizes-with
49 Ordering non-atomic operations
50 What does it mean to design for concurrency
51 Lock-based concurrent data structures
52 A thread-safe queue using locks and condition variables
53 A thread-safe queue using fine-grained locks and condition variables Part 1
54 A thread-safe queue using fine-grained locks and condition variables Part 2
55 A thread-safe queue using fine-grained locks and condition variables Part 3
56 Designing more complex lock-based data structures
57 Writing a thread-safe list using locks
58 Definitions and consequences
59 Wait-free data structures
60 Examples of lock-free data structures
61 Stopping those pesky leaks – managing memory in lock-free data structures
62 Detecting nodes that can’t be reclaimed using hazard pointers Part 1
63 Detecting nodes that can’t be reclaimed using hazard pointers Part 2
64 Detecting nodes in use with reference counting
65 Applying the memory model to the lock-free stack
66 Writing a thread-safe queue without locks Part 1
67 Writing a thread-safe queue without locks Part 2
68 Writing a thread-safe queue without locks Part 3
69 Guidelines for writing lock-free data structures
70 Techniques for dividing work between threads
71 Dividing data recursively
72 Dividing work by task type
73 Factors affecting the performance of concurrent code
74 False sharing
75 Designing data structures for multithreaded performance
76 Additional considerations when designing for concurrency
77 Scalability and Amdahl’s law
78 Designing concurrent code in practice
79 A parallel implementation of std – -find
80 A parallel implementation of std – -partial sum Part 1
81 A parallel implementation of std – -partial sum Part 2
82 Thread pools
83 Waiting for tasks submitted to a thread pool
84 Tasks that wait for other tasks
85 Work stealing
86 Interrupting threads
87 Interrupting a condition variable wait
88 Handling interruptions
89 Parallelizing the standard library algorithms
90 std – -execution – -parallel policy
91 The parallel algorithms from the C++ Standard Library
92 Examples of using parallel algorithms
93 Types of concurrency-related bugs
94 Techniques for locating concurrency-related bugs
95 Locating concurrency-related bugs by testing
96 Multithreaded testing techniques
97 Structuring multithreaded test code