Concurrent and Parallel Programming Concepts

Video description

In this Concurrent and Parallel Programming Concepts training course, expert author Martin Kalin will teach you everything you need to know to master concurrent and parallel programming. This course is designed for users that already a basic working knowledge of programming concepts.

You will start by learning about concurrency and parallelism, then jumping into learning the basics of multiprocessing. From there, Martin will teach you about multiprocessing through richer code examples, as well as multithreading through richer code examples. This video tutorial also covers thread-safety and high-level concurrent types in Java, options for thread synchronization and cooperation, and concurrency and non-blocking I/O. Finally, you will learn the basics of parallelism, parallelism and performance, and parallelism and distributed computing.

Once you have completed this computer based training course, you will have learned everything you need to know about concurrent and parallel programming. Working files are included, allowing you to follow along with the author throughout the lessons.

Table of contents

  1. Introduction
    1. Overview Of Concurrency, Parallelism, And Non-Blocking I-O
    2. About The Author
    3. Technical Definitions Of Concurrency And Parallelism
    4. Why Examples In Various Programming Languages?
    5. The Big Picture - Apps, System Libraries, And Kernel Routines
    6. Getting Started
  2. Concurrency And Parallelism
    1. Processes And Threads
    2. Multiprocessing
    3. Multithreading
    4. Non-Blocking I-O
    5. Chapter Review
    6. Hybrid Approaches - The Rule, Not The Exception
  3. Multiprocessing Basics
    1. Overview Of The First Multiprocessing Example - Unnamed Pipes In C
    2. Source Code For The First Multiprocessing Example
    3. Overview Of The Second Multiprocessing Example - Named Pipes In C
    4. Source Code For The Second Multiprocessing Example
    5. Multiprocessing The Nginx Web Server
    6. Overview Of Execing And Forking Options In Multiprocessing
    7. Source Code For The Execing Multiprocessing Example
    8. Process Tracking And Management
  4. Multiprocessing Through Richer Code Examples
    1. Multiprocessing In Node JS
    2. Interprocess Communication Mechanisms - IPC
    3. Overview Of The Shared-Memory IPC Example
    4. Source Code For The Shared-Memory IPC Example
    5. The Nginx Web Server And Unicorn App Server Architecture
    6. Overview Of The Three Sample Web Servers
    7. The Multiprocessing Web Server
    8. Exercise - Which Process Prints What And Why?
    9. Upsides And Downsides Of Multiprocessing
  5. Multithreading Basics
    1. Overview Of Multithreading
    2. A Sample Race Condition In Java
    3. Analysis Of The Race Condition Code
    4. Overview Of Explicit Thread Locking
    5. A Sample Deadlock In Java
    6. High-Level Concurrency Management In Multithreading
    7. Wrap Up Of Multithreading Basics
    8. Exercise - Timing The Cost Of Explicit Locking
  6. Multithreading Through Richer Code Examples
    1. The Miser-Spendthrift Problem In C
    2. Fixing The Miser-Spendthrift Problem In C
    3. Overview Of The Miser-Spendthrift Problem In Java
    4. Miser-Spendthrift Examples In Java
    5. Thread Synchronization As Cooperation
    6. The Thread-Safe Stack Example In Java
    7. The Multithreading Web Server
    8. Chapter Review
    9. Exercise - Thread Pools And Thread Cooperation
    10. Race Condition Exercise
  7. Thread-Safety And High-Level Concurrent Types In Java
    1. Thread Safety Through High-Level Thread-Safe Data Types
    2. Overview Of The BlockingQueue Example In Java
    3. The BlockingQueue Example - The Java Code
    4. Overview Of The Semaphores Example
    5. The Semaphore-Executor Code Example In Java
    6. Overview Of The Fork-Join Framework In Java
    7. The Filesearcher Example In Java
    8. Futures And Callables In Java - A Code Example
    9. Thread Safety Through Immutable Types And Pure Functions
    10. Chapter Review
    11. Exercise - A Producer-Consumer Program With Thread-Safe Channels
  8. Options For Thread Synchronization And Cooperation
    1. Locking Memory Versus Thread-Safe Channels And Memory Owners
    2. Overview Of Goroutines And Channels
    3. Explicit Locking In Go - The Miser-Spendthrift Problem Redux
    4. Thread-Pooling And Thread-Safe Channels In Go - The Miser-Spendthrift Problem Yet Again
    5. Chapter Review
  9. Concurrency And Non-Blocking I-O
    1. What Exactly Is Non-Blocking I-O?
    2. Non-Blocking I-O As A Concurrency Mechanism
    3. Overview Of The Epoller Example In C
    4. The Epoller Code Modules In C
    5. Overview Of The Non-Blocking I-O Example In Java
    6. The Non-Blocking Server Code - Java
    7. The Non-Blocking Client Code - Java
    8. Overview Of The Polling Server Web Server
    9. The Code For The Polling Server
    10. Exercise - Polling Multiple Data Sources Using Non-Blocking I-O
  10. Parallelism Basics
    1. Overview Of Parallelism Beyond Concurrency
    2. Flynn Taxonomy As A Starting Point
    3. A SIMD Auto Vectorization Code Example In C
    4. The Parallel Instructions Of The SIMD Example In The Assembly Code
    5. Timing The Performance Boost From Parallelism - A Code Example
    6. Overview Of The OpenMP Framework For Auto Vectorization
    7. OpenMP Basics In A Code Example
    8. The Miser-Spendthrift Problem In OpenMP
    9. SIMD Programming In OpenMP
    10. Wrap Up On Data Parallelism - SIMD Basics
  11. Parallelism And Performance
    1. How Can Performance Gains Through Parallelism Be Measured?
    2. The ParallelSort Program In Java
    3. Amdahls Law By Example
    4. Exercise - Use Timings To Get Data On Performance Trends
  12. Parallelism And Distributed Computing
    1. Distributed Systems And Parallelism Overview
    2. Map-Reduce Overview
    3. Java 8 Support For Map-Reduce Operations
    4. Map-Reduce Code Example - The Book Index Program In Java
    5. OpenMPI Overview
    6. OpenMPI Example - MPI Basics
    7. OpenMPI Example - MPI Message Passing
    8. Wrap Up Of Distributed Systems And Parallelism
    9. Exercise - Code An OpenMPI Solution To The Book Index Map-Reduce Problem
  13. Conclusion
    1. Course Wrap Up

Product information

  • Title: Concurrent and Parallel Programming Concepts
  • Author(s): Martin Kalin
  • Release date: October 2015
  • Publisher(s): Infinite Skills
  • ISBN: 9781771375313